?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH 22/57][Arm][GAS] Add support for MVE instructions: vmlaldav, vmlalv, vmlsldav...
[binutils-gdb.git] / sim / d10v / simops.c
blob92fd82710fd53f9a28bf72439d61b50d73e5440b
1 #include "config.h"
2
3 #include <signal.h>
4 #include <errno.h>
5 #include <sys/types.h>
6 #include <sys/stat.h>
7 #ifdef HAVE_UNISTD_H
8 #include <unistd.h>
9 #endif
10 #ifdef HAVE_STRING_H
11 #include <string.h>
12 #endif
13
14 #include "sim-main.h"
15 #include "simops.h"
16 #include "targ-vals.h"
17
18 #define EXCEPTION(sig) sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, sig)
19
20 enum op_types {
21 OP_VOID,
22 OP_REG,
23 OP_REG_OUTPUT,
24 OP_DREG,
25 OP_DREG_OUTPUT,
26 OP_ACCUM,
27 OP_ACCUM_OUTPUT,
28 OP_ACCUM_REVERSE,
29 OP_CR,
30 OP_CR_OUTPUT,
31 OP_CR_REVERSE,
32 OP_FLAG,
33 OP_FLAG_OUTPUT,
34 OP_CONSTANT16,
35 OP_CONSTANT8,
36 OP_CONSTANT3,
37 OP_CONSTANT4,
38 OP_MEMREF,
39 OP_MEMREF2,
40 OP_MEMREF3,
41 OP_POSTDEC,
42 OP_POSTINC,
43 OP_PREDEC,
44 OP_R0,
45 OP_R1,
46 OP_R2,
47 };
48
49
50 enum {
51 PSW_MASK = (PSW_SM_BIT
52 | PSW_EA_BIT
53 | PSW_DB_BIT
54 | PSW_IE_BIT
55 | PSW_RP_BIT
56 | PSW_MD_BIT
57 | PSW_FX_BIT
58 | PSW_ST_BIT
59 | PSW_F0_BIT
60 | PSW_F1_BIT
61 | PSW_C_BIT),
62 /* The following bits in the PSW _can't_ be set by instructions such
63 as mvtc. */
64 PSW_HW_MASK = (PSW_MASK | PSW_DM_BIT)
65 };
66
67 reg_t
68 move_to_cr (SIM_DESC sd, SIM_CPU *cpu, int cr, reg_t mask, reg_t val, int psw_hw_p)
69 {
70 /* A MASK bit is set when the corresponding bit in the CR should
71 be left alone */
72 /* This assumes that (VAL & MASK) == 0 */
73 switch (cr)
74 {
75 case PSW_CR:
76 if (psw_hw_p)
77 val &= PSW_HW_MASK;
78 else
79 val &= PSW_MASK;
80 if ((mask & PSW_SM_BIT) == 0)
81 {
82 int new_psw_sm = (val & PSW_SM_BIT) != 0;
83 /* save old SP */
84 SET_HELD_SP (PSW_SM, GPR (SP_IDX));
85 if (PSW_SM != new_psw_sm)
86 /* restore new SP */
87 SET_GPR (SP_IDX, HELD_SP (new_psw_sm));
88 }
89 if ((mask & (PSW_ST_BIT | PSW_FX_BIT)) == 0)
90 {
91 if (val & PSW_ST_BIT && !(val & PSW_FX_BIT))
92 {
93 sim_io_printf
94 (sd,
95 "ERROR at PC 0x%x: ST can only be set when FX is set.\n",
96 PC<<2);
97 EXCEPTION (SIM_SIGILL);
98 }
99 }
100 /* keep an up-to-date psw around for tracing */
101 State.trace.psw = (State.trace.psw & mask) | val;
102 break;
103 case BPSW_CR:
104 case DPSW_CR:
105 /* Just like PSW, mask things like DM out. */
106 if (psw_hw_p)
107 val &= PSW_HW_MASK;
108 else
109 val &= PSW_MASK;
110 break;
111 case MOD_S_CR:
112 case MOD_E_CR:
113 val &= ~1;
114 break;
115 default:
116 break;
117 }
118 /* only issue an update if the register is being changed */
119 if ((State.cregs[cr] & ~mask) != val)
120 SLOT_PEND_MASK (State.cregs[cr], mask, val);
121 return val;
122 }
123
124 #ifdef DEBUG
125 static void trace_input_func (SIM_DESC sd,
126 const char *name,
127 enum op_types in1,
128 enum op_types in2,
129 enum op_types in3);
130
131 #define trace_input(name, in1, in2, in3) do { if (d10v_debug) trace_input_func (sd, name, in1, in2, in3); } while (0)
132
133 #ifndef SIZE_INSTRUCTION
134 #define SIZE_INSTRUCTION 8
135 #endif
136
137 #ifndef SIZE_OPERANDS
138 #define SIZE_OPERANDS 18
139 #endif
140
141 #ifndef SIZE_VALUES
142 #define SIZE_VALUES 13
143 #endif
144
145 #ifndef SIZE_LOCATION
146 #define SIZE_LOCATION 20
147 #endif
148
149 #ifndef SIZE_PC
150 #define SIZE_PC 6
151 #endif
152
153 #ifndef SIZE_LINE_NUMBER
154 #define SIZE_LINE_NUMBER 4
155 #endif
156
157 static void
158 trace_input_func (SIM_DESC sd, const char *name, enum op_types in1, enum op_types in2, enum op_types in3)
159 {
160 char *comma;
161 enum op_types in[3];
162 int i;
163 char buf[1024];
164 char *p;
165 long tmp;
166 char *type;
167 const char *filename;
168 const char *functionname;
169 unsigned int linenumber;
170 bfd_vma byte_pc;
171
172 if ((d10v_debug & DEBUG_TRACE) == 0)
173 return;
174
175 switch (State.ins_type)
176 {
177 default:
178 case INS_UNKNOWN: type = " ?"; break;
179 case INS_LEFT: type = " L"; break;
180 case INS_RIGHT: type = " R"; break;
181 case INS_LEFT_PARALLEL: type = "*L"; break;
182 case INS_RIGHT_PARALLEL: type = "*R"; break;
183 case INS_LEFT_COND_TEST: type = "?L"; break;
184 case INS_RIGHT_COND_TEST: type = "?R"; break;
185 case INS_LEFT_COND_EXE: type = "&L"; break;
186 case INS_RIGHT_COND_EXE: type = "&R"; break;
187 case INS_LONG: type = " B"; break;
188 }
189
190 if ((d10v_debug & DEBUG_LINE_NUMBER) == 0)
191 sim_io_printf (sd,
192 "0x%.*x %s: %-*s ",
193 SIZE_PC, (unsigned)PC,
194 type,
195 SIZE_INSTRUCTION, name);
196
197 else
198 {
199 buf[0] = '\0';
200 byte_pc = PC;
201 if (STATE_TEXT_SECTION (sd)
202 && byte_pc >= STATE_TEXT_START (sd)
203 && byte_pc < STATE_TEXT_END (sd))
204 {
205 filename = (const char *)0;
206 functionname = (const char *)0;
207 linenumber = 0;
208 if (bfd_find_nearest_line (STATE_PROG_BFD (sd),
209 STATE_TEXT_SECTION (sd),
210 (struct bfd_symbol **)0,
211 byte_pc - STATE_TEXT_START (sd),
212 &filename, &functionname, &linenumber))
213 {
214 p = buf;
215 if (linenumber)
216 {
217 sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, linenumber);
218 p += strlen (p);
219 }
220 else
221 {
222 sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---");
223 p += SIZE_LINE_NUMBER+2;
224 }
225
226 if (functionname)
227 {
228 sprintf (p, "%s ", functionname);
229 p += strlen (p);
230 }
231 else if (filename)
232 {
233 char *q = strrchr (filename, '/');
234 sprintf (p, "%s ", (q) ? q+1 : filename);
235 p += strlen (p);
236 }
237
238 if (*p == ' ')
239 *p = '\0';
240 }
241 }
242
243 sim_io_printf (sd,
244 "0x%.*x %s: %-*.*s %-*s ",
245 SIZE_PC, (unsigned)PC,
246 type,
247 SIZE_LOCATION, SIZE_LOCATION, buf,
248 SIZE_INSTRUCTION, name);
249 }
250
251 in[0] = in1;
252 in[1] = in2;
253 in[2] = in3;
254 comma = "";
255 p = buf;
256 for (i = 0; i < 3; i++)
257 {
258 switch (in[i])
259 {
260 case OP_VOID:
261 case OP_R0:
262 case OP_R1:
263 case OP_R2:
264 break;
265
266 case OP_REG:
267 case OP_REG_OUTPUT:
268 case OP_DREG:
269 case OP_DREG_OUTPUT:
270 sprintf (p, "%sr%d", comma, OP[i]);
271 p += strlen (p);
272 comma = ",";
273 break;
274
275 case OP_CR:
276 case OP_CR_OUTPUT:
277 case OP_CR_REVERSE:
278 sprintf (p, "%scr%d", comma, OP[i]);
279 p += strlen (p);
280 comma = ",";
281 break;
282
283 case OP_ACCUM:
284 case OP_ACCUM_OUTPUT:
285 case OP_ACCUM_REVERSE:
286 sprintf (p, "%sa%d", comma, OP[i]);
287 p += strlen (p);
288 comma = ",";
289 break;
290
291 case OP_CONSTANT16:
292 sprintf (p, "%s%d", comma, OP[i]);
293 p += strlen (p);
294 comma = ",";
295 break;
296
297 case OP_CONSTANT8:
298 sprintf (p, "%s%d", comma, SEXT8(OP[i]));
299 p += strlen (p);
300 comma = ",";
301 break;
302
303 case OP_CONSTANT4:
304 sprintf (p, "%s%d", comma, SEXT4(OP[i]));
305 p += strlen (p);
306 comma = ",";
307 break;
308
309 case OP_CONSTANT3:
310 sprintf (p, "%s%d", comma, SEXT3(OP[i]));
311 p += strlen (p);
312 comma = ",";
313 break;
314
315 case OP_MEMREF:
316 sprintf (p, "%s@r%d", comma, OP[i]);
317 p += strlen (p);
318 comma = ",";
319 break;
320
321 case OP_MEMREF2:
322 sprintf (p, "%s@(%d,r%d)", comma, (int16)OP[i], OP[i+1]);
323 p += strlen (p);
324 comma = ",";
325 break;
326
327 case OP_MEMREF3:
328 sprintf (p, "%s@%d", comma, OP[i]);
329 p += strlen (p);
330 comma = ",";
331 break;
332
333 case OP_POSTINC:
334 sprintf (p, "%s@r%d+", comma, OP[i]);
335 p += strlen (p);
336 comma = ",";
337 break;
338
339 case OP_POSTDEC:
340 sprintf (p, "%s@r%d-", comma, OP[i]);
341 p += strlen (p);
342 comma = ",";
343 break;
344
345 case OP_PREDEC:
346 sprintf (p, "%s@-r%d", comma, OP[i]);
347 p += strlen (p);
348 comma = ",";
349 break;
350
351 case OP_FLAG:
352 case OP_FLAG_OUTPUT:
353 if (OP[i] == 0)
354 sprintf (p, "%sf0", comma);
355
356 else if (OP[i] == 1)
357 sprintf (p, "%sf1", comma);
358
359 else
360 sprintf (p, "%sc", comma);
361
362 p += strlen (p);
363 comma = ",";
364 break;
365 }
366 }
367
368 if ((d10v_debug & DEBUG_VALUES) == 0)
369 {
370 *p++ = '\n';
371 *p = '\0';
372 sim_io_printf (sd, "%s", buf);
373 }
374 else
375 {
376 *p = '\0';
377 sim_io_printf (sd, "%-*s", SIZE_OPERANDS, buf);
378
379 p = buf;
380 for (i = 0; i < 3; i++)
381 {
382 buf[0] = '\0';
383 switch (in[i])
384 {
385 case OP_VOID:
386 sim_io_printf (sd, "%*s", SIZE_VALUES, "");
387 break;
388
389 case OP_REG_OUTPUT:
390 case OP_DREG_OUTPUT:
391 case OP_CR_OUTPUT:
392 case OP_ACCUM_OUTPUT:
393 case OP_FLAG_OUTPUT:
394 sim_io_printf (sd, "%*s", SIZE_VALUES, "---");
395 break;
396
397 case OP_REG:
398 case OP_MEMREF:
399 case OP_POSTDEC:
400 case OP_POSTINC:
401 case OP_PREDEC:
402 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
403 (uint16) GPR (OP[i]));
404 break;
405
406 case OP_MEMREF3:
407 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "", (uint16) OP[i]);
408 break;
409
410 case OP_DREG:
411 tmp = (long)((((uint32) GPR (OP[i])) << 16) | ((uint32) GPR (OP[i] + 1)));
412 sim_io_printf (sd, "%*s0x%.8lx", SIZE_VALUES-10, "", tmp);
413 break;
414
415 case OP_CR:
416 case OP_CR_REVERSE:
417 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
418 (uint16) CREG (OP[i]));
419 break;
420
421 case OP_ACCUM:
422 case OP_ACCUM_REVERSE:
423 sim_io_printf (sd, "%*s0x%.2x%.8lx", SIZE_VALUES-12, "",
424 ((int)(ACC (OP[i]) >> 32) & 0xff),
425 ((unsigned long) ACC (OP[i])) & 0xffffffff);
426 break;
427
428 case OP_CONSTANT16:
429 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
430 (uint16)OP[i]);
431 break;
432
433 case OP_CONSTANT4:
434 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
435 (uint16)SEXT4(OP[i]));
436 break;
437
438 case OP_CONSTANT8:
439 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
440 (uint16)SEXT8(OP[i]));
441 break;
442
443 case OP_CONSTANT3:
444 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
445 (uint16)SEXT3(OP[i]));
446 break;
447
448 case OP_FLAG:
449 if (OP[i] == 0)
450 sim_io_printf (sd, "%*sF0 = %d", SIZE_VALUES-6, "",
451 PSW_F0 != 0);
452
453 else if (OP[i] == 1)
454 sim_io_printf (sd, "%*sF1 = %d", SIZE_VALUES-6, "",
455 PSW_F1 != 0);
456
457 else
458 sim_io_printf (sd, "%*sC = %d", SIZE_VALUES-5, "",
459 PSW_C != 0);
460
461 break;
462
463 case OP_MEMREF2:
464 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
465 (uint16)OP[i]);
466 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
467 (uint16)GPR (OP[i + 1]));
468 i++;
469 break;
470
471 case OP_R0:
472 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
473 (uint16) GPR (0));
474 break;
475
476 case OP_R1:
477 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
478 (uint16) GPR (1));
479 break;
480
481 case OP_R2:
482 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
483 (uint16) GPR (2));
484 break;
485
486 }
487 }
488 }
489
490 sim_io_flush_stdout (sd);
491 }
492
493 static void
494 do_trace_output_flush (SIM_DESC sd)
495 {
496 sim_io_flush_stdout (sd);
497 }
498
499 static void
500 do_trace_output_finish (SIM_DESC sd)
501 {
502 sim_io_printf (sd,
503 " F0=%d F1=%d C=%d\n",
504 (State.trace.psw & PSW_F0_BIT) != 0,
505 (State.trace.psw & PSW_F1_BIT) != 0,
506 (State.trace.psw & PSW_C_BIT) != 0);
507 sim_io_flush_stdout (sd);
508 }
509
510 static void
511 trace_output_40 (SIM_DESC sd, uint64 val)
512 {
513 if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
514 {
515 sim_io_printf (sd,
516 " :: %*s0x%.2x%.8lx",
517 SIZE_VALUES - 12,
518 "",
519 ((int)(val >> 32) & 0xff),
520 ((unsigned long) val) & 0xffffffff);
521 do_trace_output_finish (sd);
522 }
523 }
524
525 static void
526 trace_output_32 (SIM_DESC sd, uint32 val)
527 {
528 if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
529 {
530 sim_io_printf (sd,
531 " :: %*s0x%.8x",
532 SIZE_VALUES - 10,
533 "",
534 (int) val);
535 do_trace_output_finish (sd);
536 }
537 }
538
539 static void
540 trace_output_16 (SIM_DESC sd, uint16 val)
541 {
542 if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
543 {
544 sim_io_printf (sd,
545 " :: %*s0x%.4x",
546 SIZE_VALUES - 6,
547 "",
548 (int) val);
549 do_trace_output_finish (sd);
550 }
551 }
552
553 static void
554 trace_output_void (SIM_DESC sd)
555 {
556 if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
557 {
558 sim_io_printf (sd, "\n");
559 do_trace_output_flush (sd);
560 }
561 }
562
563 static void
564 trace_output_flag (SIM_DESC sd)
565 {
566 if ((d10v_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
567 {
568 sim_io_printf (sd,
569 " :: %*s",
570 SIZE_VALUES,
571 "");
572 do_trace_output_finish (sd);
573 }
574 }
575
576
577
578
579 #else
580 #define trace_input(NAME, IN1, IN2, IN3)
581 #define trace_output(RESULT)
582 #endif
583
584 /* abs */
585 void
586 OP_4607 (SIM_DESC sd, SIM_CPU *cpu)
587 {
588 int16 tmp;
589 trace_input ("abs", OP_REG, OP_VOID, OP_VOID);
590 SET_PSW_F1 (PSW_F0);
591 tmp = GPR(OP[0]);
592 if (tmp < 0)
593 {
594 tmp = - tmp;
595 SET_PSW_F0 (1);
596 }
597 else
598 SET_PSW_F0 (0);
599 SET_GPR (OP[0], tmp);
600 trace_output_16 (sd, tmp);
601 }
602
603 /* abs */
604 void
605 OP_5607 (SIM_DESC sd, SIM_CPU *cpu)
606 {
607 int64 tmp;
608 trace_input ("abs", OP_ACCUM, OP_VOID, OP_VOID);
609 SET_PSW_F1 (PSW_F0);
610
611 tmp = SEXT40 (ACC (OP[0]));
612 if (tmp < 0 )
613 {
614 tmp = - tmp;
615 if (PSW_ST)
616 {
617 if (tmp > SEXT40(MAX32))
618 tmp = (MAX32);
619 else if (tmp < SEXT40(MIN32))
620 tmp = (MIN32);
621 else
622 tmp = (tmp & MASK40);
623 }
624 else
625 tmp = (tmp & MASK40);
626 SET_PSW_F0 (1);
627 }
628 else
629 {
630 tmp = (tmp & MASK40);
631 SET_PSW_F0 (0);
632 }
633 SET_ACC (OP[0], tmp);
634 trace_output_40 (sd, tmp);
635 }
636
637 /* add */
638 void
639 OP_200 (SIM_DESC sd, SIM_CPU *cpu)
640 {
641 uint16 a = GPR (OP[0]);
642 uint16 b = GPR (OP[1]);
643 uint16 tmp = (a + b);
644 trace_input ("add", OP_REG, OP_REG, OP_VOID);
645 SET_PSW_C (a > tmp);
646 SET_GPR (OP[0], tmp);
647 trace_output_16 (sd, tmp);
648 }
649
650 /* add */
651 void
652 OP_1201 (SIM_DESC sd, SIM_CPU *cpu)
653 {
654 int64 tmp;
655 tmp = SEXT40(ACC (OP[0])) + (SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1));
656
657 trace_input ("add", OP_ACCUM, OP_REG, OP_VOID);
658 if (PSW_ST)
659 {
660 if (tmp > SEXT40(MAX32))
661 tmp = (MAX32);
662 else if (tmp < SEXT40(MIN32))
663 tmp = (MIN32);
664 else
665 tmp = (tmp & MASK40);
666 }
667 else
668 tmp = (tmp & MASK40);
669 SET_ACC (OP[0], tmp);
670 trace_output_40 (sd, tmp);
671 }
672
673 /* add */
674 void
675 OP_1203 (SIM_DESC sd, SIM_CPU *cpu)
676 {
677 int64 tmp;
678 tmp = SEXT40(ACC (OP[0])) + SEXT40(ACC (OP[1]));
679
680 trace_input ("add", OP_ACCUM, OP_ACCUM, OP_VOID);
681 if (PSW_ST)
682 {
683 if (tmp > SEXT40(MAX32))
684 tmp = (MAX32);
685 else if (tmp < SEXT40(MIN32))
686 tmp = (MIN32);
687 else
688 tmp = (tmp & MASK40);
689 }
690 else
691 tmp = (tmp & MASK40);
692 SET_ACC (OP[0], tmp);
693 trace_output_40 (sd, tmp);
694 }
695
696 /* add2w */
697 void
698 OP_1200 (SIM_DESC sd, SIM_CPU *cpu)
699 {
700 uint32 tmp;
701 uint32 a = (GPR (OP[0])) << 16 | GPR (OP[0] + 1);
702 uint32 b = (GPR (OP[1])) << 16 | GPR (OP[1] + 1);
703 trace_input ("add2w", OP_DREG, OP_DREG, OP_VOID);
704 tmp = a + b;
705 SET_PSW_C (tmp < a);
706 SET_GPR (OP[0] + 0, (tmp >> 16));
707 SET_GPR (OP[0] + 1, (tmp & 0xFFFF));
708 trace_output_32 (sd, tmp);
709 }
710
711 /* add3 */
712 void
713 OP_1000000 (SIM_DESC sd, SIM_CPU *cpu)
714 {
715 uint16 a = GPR (OP[1]);
716 uint16 b = OP[2];
717 uint16 tmp = (a + b);
718 trace_input ("add3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16);
719 SET_PSW_C (tmp < a);
720 SET_GPR (OP[0], tmp);
721 trace_output_16 (sd, tmp);
722 }
723
724 /* addac3 */
725 void
726 OP_17000200 (SIM_DESC sd, SIM_CPU *cpu)
727 {
728 int64 tmp;
729 tmp = SEXT40(ACC (OP[2])) + SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1));
730
731 trace_input ("addac3", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM);
732 SET_GPR (OP[0] + 0, ((tmp >> 16) & 0xffff));
733 SET_GPR (OP[0] + 1, (tmp & 0xffff));
734 trace_output_32 (sd, tmp);
735 }
736
737 /* addac3 */
738 void
739 OP_17000202 (SIM_DESC sd, SIM_CPU *cpu)
740 {
741 int64 tmp;
742 tmp = SEXT40(ACC (OP[1])) + SEXT40(ACC (OP[2]));
743
744 trace_input ("addac3", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM);
745 SET_GPR (OP[0] + 0, (tmp >> 16) & 0xffff);
746 SET_GPR (OP[0] + 1, tmp & 0xffff);
747 trace_output_32 (sd, tmp);
748 }
749
750 /* addac3s */
751 void
752 OP_17001200 (SIM_DESC sd, SIM_CPU *cpu)
753 {
754 int64 tmp;
755 SET_PSW_F1 (PSW_F0);
756
757 trace_input ("addac3s", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM);
758 tmp = SEXT40 (ACC (OP[2])) + SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1));
759 if (tmp > SEXT40(MAX32))
760 {
761 tmp = (MAX32);
762 SET_PSW_F0 (1);
763 }
764 else if (tmp < SEXT40(MIN32))
765 {
766 tmp = (MIN32);
767 SET_PSW_F0 (1);
768 }
769 else
770 {
771 SET_PSW_F0 (0);
772 }
773 SET_GPR (OP[0] + 0, (tmp >> 16) & 0xffff);
774 SET_GPR (OP[0] + 1, (tmp & 0xffff));
775 trace_output_32 (sd, tmp);
776 }
777
778 /* addac3s */
779 void
780 OP_17001202 (SIM_DESC sd, SIM_CPU *cpu)
781 {
782 int64 tmp;
783 SET_PSW_F1 (PSW_F0);
784
785 trace_input ("addac3s", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM);
786 tmp = SEXT40(ACC (OP[1])) + SEXT40(ACC (OP[2]));
787 if (tmp > SEXT40(MAX32))
788 {
789 tmp = (MAX32);
790 SET_PSW_F0 (1);
791 }
792 else if (tmp < SEXT40(MIN32))
793 {
794 tmp = (MIN32);
795 SET_PSW_F0 (1);
796 }
797 else
798 {
799 SET_PSW_F0 (0);
800 }
801 SET_GPR (OP[0] + 0, (tmp >> 16) & 0xffff);
802 SET_GPR (OP[0] + 1, (tmp & 0xffff));
803 trace_output_32 (sd, tmp);
804 }
805
806 /* addi */
807 void
808 OP_201 (SIM_DESC sd, SIM_CPU *cpu)
809 {
810 uint16 a = GPR (OP[0]);
811 uint16 b;
812 uint16 tmp;
813 if (OP[1] == 0)
814 OP[1] = 16;
815 b = OP[1];
816 tmp = (a + b);
817 trace_input ("addi", OP_REG, OP_CONSTANT16, OP_VOID);
818 SET_PSW_C (tmp < a);
819 SET_GPR (OP[0], tmp);
820 trace_output_16 (sd, tmp);
821 }
822
823 /* and */
824 void
825 OP_C00 (SIM_DESC sd, SIM_CPU *cpu)
826 {
827 uint16 tmp = GPR (OP[0]) & GPR (OP[1]);
828 trace_input ("and", OP_REG, OP_REG, OP_VOID);
829 SET_GPR (OP[0], tmp);
830 trace_output_16 (sd, tmp);
831 }
832
833 /* and3 */
834 void
835 OP_6000000 (SIM_DESC sd, SIM_CPU *cpu)
836 {
837 uint16 tmp = GPR (OP[1]) & OP[2];
838 trace_input ("and3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16);
839 SET_GPR (OP[0], tmp);
840 trace_output_16 (sd, tmp);
841 }
842
843 /* bclri */
844 void
845 OP_C01 (SIM_DESC sd, SIM_CPU *cpu)
846 {
847 int16 tmp;
848 trace_input ("bclri", OP_REG, OP_CONSTANT16, OP_VOID);
849 tmp = (GPR (OP[0]) &~(0x8000 >> OP[1]));
850 SET_GPR (OP[0], tmp);
851 trace_output_16 (sd, tmp);
852 }
853
854 /* bl.s */
855 void
856 OP_4900 (SIM_DESC sd, SIM_CPU *cpu)
857 {
858 trace_input ("bl.s", OP_CONSTANT8, OP_R0, OP_R1);
859 SET_GPR (13, PC + 1);
860 JMP( PC + SEXT8 (OP[0]));
861 trace_output_void (sd);
862 }
863
864 /* bl.l */
865 void
866 OP_24800000 (SIM_DESC sd, SIM_CPU *cpu)
867 {
868 trace_input ("bl.l", OP_CONSTANT16, OP_R0, OP_R1);
869 SET_GPR (13, (PC + 1));
870 JMP (PC + OP[0]);
871 trace_output_void (sd);
872 }
873
874 /* bnoti */
875 void
876 OP_A01 (SIM_DESC sd, SIM_CPU *cpu)
877 {
878 int16 tmp;
879 trace_input ("bnoti", OP_REG, OP_CONSTANT16, OP_VOID);
880 tmp = (GPR (OP[0]) ^ (0x8000 >> OP[1]));
881 SET_GPR (OP[0], tmp);
882 trace_output_16 (sd, tmp);
883 }
884
885 /* bra.s */
886 void
887 OP_4800 (SIM_DESC sd, SIM_CPU *cpu)
888 {
889 trace_input ("bra.s", OP_CONSTANT8, OP_VOID, OP_VOID);
890 JMP (PC + SEXT8 (OP[0]));
891 trace_output_void (sd);
892 }
893
894 /* bra.l */
895 void
896 OP_24000000 (SIM_DESC sd, SIM_CPU *cpu)
897 {
898 trace_input ("bra.l", OP_CONSTANT16, OP_VOID, OP_VOID);
899 JMP (PC + OP[0]);
900 trace_output_void (sd);
901 }
902
903 /* brf0f.s */
904 void
905 OP_4A00 (SIM_DESC sd, SIM_CPU *cpu)
906 {
907 trace_input ("brf0f.s", OP_CONSTANT8, OP_VOID, OP_VOID);
908 if (!PSW_F0)
909 JMP (PC + SEXT8 (OP[0]));
910 trace_output_flag (sd);
911 }
912
913 /* brf0f.l */
914 void
915 OP_25000000 (SIM_DESC sd, SIM_CPU *cpu)
916 {
917 trace_input ("brf0f.l", OP_CONSTANT16, OP_VOID, OP_VOID);
918 if (!PSW_F0)
919 JMP (PC + OP[0]);
920 trace_output_flag (sd);
921 }
922
923 /* brf0t.s */
924 void
925 OP_4B00 (SIM_DESC sd, SIM_CPU *cpu)
926 {
927 trace_input ("brf0t.s", OP_CONSTANT8, OP_VOID, OP_VOID);
928 if (PSW_F0)
929 JMP (PC + SEXT8 (OP[0]));
930 trace_output_flag (sd);
931 }
932
933 /* brf0t.l */
934 void
935 OP_25800000 (SIM_DESC sd, SIM_CPU *cpu)
936 {
937 trace_input ("brf0t.l", OP_CONSTANT16, OP_VOID, OP_VOID);
938 if (PSW_F0)
939 JMP (PC + OP[0]);
940 trace_output_flag (sd);
941 }
942
943 /* bseti */
944 void
945 OP_801 (SIM_DESC sd, SIM_CPU *cpu)
946 {
947 int16 tmp;
948 trace_input ("bseti", OP_REG, OP_CONSTANT16, OP_VOID);
949 tmp = (GPR (OP[0]) | (0x8000 >> OP[1]));
950 SET_GPR (OP[0], tmp);
951 trace_output_16 (sd, tmp);
952 }
953
954 /* btsti */
955 void
956 OP_E01 (SIM_DESC sd, SIM_CPU *cpu)
957 {
958 trace_input ("btsti", OP_REG, OP_CONSTANT16, OP_VOID);
959 SET_PSW_F1 (PSW_F0);
960 SET_PSW_F0 ((GPR (OP[0]) & (0x8000 >> OP[1])) ? 1 : 0);
961 trace_output_flag (sd);
962 }
963
964 /* clrac */
965 void
966 OP_5601 (SIM_DESC sd, SIM_CPU *cpu)
967 {
968 trace_input ("clrac", OP_ACCUM_OUTPUT, OP_VOID, OP_VOID);
969 SET_ACC (OP[0], 0);
970 trace_output_40 (sd, 0);
971 }
972
973 /* cmp */
974 void
975 OP_600 (SIM_DESC sd, SIM_CPU *cpu)
976 {
977 trace_input ("cmp", OP_REG, OP_REG, OP_VOID);
978 SET_PSW_F1 (PSW_F0);
979 SET_PSW_F0 (((int16)(GPR (OP[0])) < (int16)(GPR (OP[1]))) ? 1 : 0);
980 trace_output_flag (sd);
981 }
982
983 /* cmp */
984 void
985 OP_1603 (SIM_DESC sd, SIM_CPU *cpu)
986 {
987 trace_input ("cmp", OP_ACCUM, OP_ACCUM, OP_VOID);
988 SET_PSW_F1 (PSW_F0);
989 SET_PSW_F0 ((SEXT40(ACC (OP[0])) < SEXT40(ACC (OP[1]))) ? 1 : 0);
990 trace_output_flag (sd);
991 }
992
993 /* cmpeq */
994 void
995 OP_400 (SIM_DESC sd, SIM_CPU *cpu)
996 {
997 trace_input ("cmpeq", OP_REG, OP_REG, OP_VOID);
998 SET_PSW_F1 (PSW_F0);
999 SET_PSW_F0 ((GPR (OP[0]) == GPR (OP[1])) ? 1 : 0);
1000 trace_output_flag (sd);
1001 }
1002
1003 /* cmpeq */
1004 void
1005 OP_1403 (SIM_DESC sd, SIM_CPU *cpu)
1006 {
1007 trace_input ("cmpeq", OP_ACCUM, OP_ACCUM, OP_VOID);
1008 SET_PSW_F1 (PSW_F0);
1009 SET_PSW_F0 (((ACC (OP[0]) & MASK40) == (ACC (OP[1]) & MASK40)) ? 1 : 0);
1010 trace_output_flag (sd);
1011 }
1012
1013 /* cmpeqi.s */
1014 void
1015 OP_401 (SIM_DESC sd, SIM_CPU *cpu)
1016 {
1017 trace_input ("cmpeqi.s", OP_REG, OP_CONSTANT4, OP_VOID);
1018 SET_PSW_F1 (PSW_F0);
1019 SET_PSW_F0 ((GPR (OP[0]) == (reg_t) SEXT4 (OP[1])) ? 1 : 0);
1020 trace_output_flag (sd);
1021 }
1022
1023 /* cmpeqi.l */
1024 void
1025 OP_2000000 (SIM_DESC sd, SIM_CPU *cpu)
1026 {
1027 trace_input ("cmpeqi.l", OP_REG, OP_CONSTANT16, OP_VOID);
1028 SET_PSW_F1 (PSW_F0);
1029 SET_PSW_F0 ((GPR (OP[0]) == (reg_t)OP[1]) ? 1 : 0);
1030 trace_output_flag (sd);
1031 }
1032
1033 /* cmpi.s */
1034 void
1035 OP_601 (SIM_DESC sd, SIM_CPU *cpu)
1036 {
1037 trace_input ("cmpi.s", OP_REG, OP_CONSTANT4, OP_VOID);
1038 SET_PSW_F1 (PSW_F0);
1039 SET_PSW_F0 (((int16)(GPR (OP[0])) < (int16)SEXT4(OP[1])) ? 1 : 0);
1040 trace_output_flag (sd);
1041 }
1042
1043 /* cmpi.l */
1044 void
1045 OP_3000000 (SIM_DESC sd, SIM_CPU *cpu)
1046 {
1047 trace_input ("cmpi.l", OP_REG, OP_CONSTANT16, OP_VOID);
1048 SET_PSW_F1 (PSW_F0);
1049 SET_PSW_F0 (((int16)(GPR (OP[0])) < (int16)(OP[1])) ? 1 : 0);
1050 trace_output_flag (sd);
1051 }
1052
1053 /* cmpu */
1054 void
1055 OP_4600 (SIM_DESC sd, SIM_CPU *cpu)
1056 {
1057 trace_input ("cmpu", OP_REG, OP_REG, OP_VOID);
1058 SET_PSW_F1 (PSW_F0);
1059 SET_PSW_F0 ((GPR (OP[0]) < GPR (OP[1])) ? 1 : 0);
1060 trace_output_flag (sd);
1061 }
1062
1063 /* cmpui */
1064 void
1065 OP_23000000 (SIM_DESC sd, SIM_CPU *cpu)
1066 {
1067 trace_input ("cmpui", OP_REG, OP_CONSTANT16, OP_VOID);
1068 SET_PSW_F1 (PSW_F0);
1069 SET_PSW_F0 ((GPR (OP[0]) < (reg_t)OP[1]) ? 1 : 0);
1070 trace_output_flag (sd);
1071 }
1072
1073 /* cpfg */
1074 void
1075 OP_4E09 (SIM_DESC sd, SIM_CPU *cpu)
1076 {
1077 uint8 val;
1078
1079 trace_input ("cpfg", OP_FLAG_OUTPUT, OP_FLAG, OP_VOID);
1080
1081 if (OP[1] == 0)
1082 val = PSW_F0;
1083 else if (OP[1] == 1)
1084 val = PSW_F1;
1085 else
1086 val = PSW_C;
1087 if (OP[0] == 0)
1088 SET_PSW_F0 (val);
1089 else
1090 SET_PSW_F1 (val);
1091
1092 trace_output_flag (sd);
1093 }
1094
1095 /* cpfg */
1096 void
1097 OP_4E0F (SIM_DESC sd, SIM_CPU *cpu)
1098 {
1099 uint8 val;
1100
1101 trace_input ("cpfg", OP_FLAG_OUTPUT, OP_FLAG, OP_VOID);
1102
1103 if (OP[1] == 0)
1104 val = PSW_F0;
1105 else if (OP[1] == 1)
1106 val = PSW_F1;
1107 else
1108 val = PSW_C;
1109 if (OP[0] == 0)
1110 SET_PSW_F0 (val);
1111 else
1112 SET_PSW_F1 (val);
1113
1114 trace_output_flag (sd);
1115 }
1116
1117 /* dbt */
1118 void
1119 OP_5F20 (SIM_DESC sd, SIM_CPU *cpu)
1120 {
1121 /* sim_io_printf (sd, "***** DBT ***** PC=%x\n",PC); */
1122
1123 /* GDB uses the instruction pair ``dbt || nop'' as a break-point.
1124 The conditional below is for either of the instruction pairs
1125 ``dbt -> XXX'' or ``dbt <- XXX'' and treats them as as cases
1126 where the dbt instruction should be interpreted.
1127
1128 The module `sim-break' provides a more effective mechanism for
1129 detecting GDB planted breakpoints. The code below may,
1130 eventually, be changed to use that mechanism. */
1131
1132 if (State.ins_type == INS_LEFT
1133 || State.ins_type == INS_RIGHT)
1134 {
1135 trace_input ("dbt", OP_VOID, OP_VOID, OP_VOID);
1136 SET_DPC (PC + 1);
1137 SET_DPSW (PSW);
1138 SET_HW_PSW (PSW_DM_BIT | (PSW & (PSW_F0_BIT | PSW_F1_BIT | PSW_C_BIT)));
1139 JMP (DBT_VECTOR_START);
1140 trace_output_void (sd);
1141 }
1142 else
1143 sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, SIM_SIGTRAP);
1144 }
1145
1146 /* divs */
1147 void
1148 OP_14002800 (SIM_DESC sd, SIM_CPU *cpu)
1149 {
1150 uint16 foo, tmp, tmpf;
1151 uint16 hi;
1152 uint16 lo;
1153
1154 trace_input ("divs", OP_DREG, OP_REG, OP_VOID);
1155 foo = (GPR (OP[0]) << 1) | (GPR (OP[0] + 1) >> 15);
1156 tmp = (int16)foo - (int16)(GPR (OP[1]));
1157 tmpf = (foo >= GPR (OP[1])) ? 1 : 0;
1158 hi = ((tmpf == 1) ? tmp : foo);
1159 lo = ((GPR (OP[0] + 1) << 1) | tmpf);
1160 SET_GPR (OP[0] + 0, hi);
1161 SET_GPR (OP[0] + 1, lo);
1162 trace_output_32 (sd, ((uint32) hi << 16) | lo);
1163 }
1164
1165 /* exef0f */
1166 void
1167 OP_4E04 (SIM_DESC sd, SIM_CPU *cpu)
1168 {
1169 trace_input ("exef0f", OP_VOID, OP_VOID, OP_VOID);
1170 State.exe = (PSW_F0 == 0);
1171 trace_output_flag (sd);
1172 }
1173
1174 /* exef0t */
1175 void
1176 OP_4E24 (SIM_DESC sd, SIM_CPU *cpu)
1177 {
1178 trace_input ("exef0t", OP_VOID, OP_VOID, OP_VOID);
1179 State.exe = (PSW_F0 != 0);
1180 trace_output_flag (sd);
1181 }
1182
1183 /* exef1f */
1184 void
1185 OP_4E40 (SIM_DESC sd, SIM_CPU *cpu)
1186 {
1187 trace_input ("exef1f", OP_VOID, OP_VOID, OP_VOID);
1188 State.exe = (PSW_F1 == 0);
1189 trace_output_flag (sd);
1190 }
1191
1192 /* exef1t */
1193 void
1194 OP_4E42 (SIM_DESC sd, SIM_CPU *cpu)
1195 {
1196 trace_input ("exef1t", OP_VOID, OP_VOID, OP_VOID);
1197 State.exe = (PSW_F1 != 0);
1198 trace_output_flag (sd);
1199 }
1200
1201 /* exefaf */
1202 void
1203 OP_4E00 (SIM_DESC sd, SIM_CPU *cpu)
1204 {
1205 trace_input ("exefaf", OP_VOID, OP_VOID, OP_VOID);
1206 State.exe = (PSW_F0 == 0) & (PSW_F1 == 0);
1207 trace_output_flag (sd);
1208 }
1209
1210 /* exefat */
1211 void
1212 OP_4E02 (SIM_DESC sd, SIM_CPU *cpu)
1213 {
1214 trace_input ("exefat", OP_VOID, OP_VOID, OP_VOID);
1215 State.exe = (PSW_F0 == 0) & (PSW_F1 != 0);
1216 trace_output_flag (sd);
1217 }
1218
1219 /* exetaf */
1220 void
1221 OP_4E20 (SIM_DESC sd, SIM_CPU *cpu)
1222 {
1223 trace_input ("exetaf", OP_VOID, OP_VOID, OP_VOID);
1224 State.exe = (PSW_F0 != 0) & (PSW_F1 == 0);
1225 trace_output_flag (sd);
1226 }
1227
1228 /* exetat */
1229 void
1230 OP_4E22 (SIM_DESC sd, SIM_CPU *cpu)
1231 {
1232 trace_input ("exetat", OP_VOID, OP_VOID, OP_VOID);
1233 State.exe = (PSW_F0 != 0) & (PSW_F1 != 0);
1234 trace_output_flag (sd);
1235 }
1236
1237 /* exp */
1238 void
1239 OP_15002A00 (SIM_DESC sd, SIM_CPU *cpu)
1240 {
1241 uint32 tmp, foo;
1242 int i;
1243
1244 trace_input ("exp", OP_REG_OUTPUT, OP_DREG, OP_VOID);
1245 if (((int16)GPR (OP[1])) >= 0)
1246 tmp = (GPR (OP[1]) << 16) | GPR (OP[1] + 1);
1247 else
1248 tmp = ~((GPR (OP[1]) << 16) | GPR (OP[1] + 1));
1249
1250 foo = 0x40000000;
1251 for (i=1;i<17;i++)
1252 {
1253 if (tmp & foo)
1254 {
1255 SET_GPR (OP[0], (i - 1));
1256 trace_output_16 (sd, i - 1);
1257 return;
1258 }
1259 foo >>= 1;
1260 }
1261 SET_GPR (OP[0], 16);
1262 trace_output_16 (sd, 16);
1263 }
1264
1265 /* exp */
1266 void
1267 OP_15002A02 (SIM_DESC sd, SIM_CPU *cpu)
1268 {
1269 int64 tmp, foo;
1270 int i;
1271
1272 trace_input ("exp", OP_REG_OUTPUT, OP_ACCUM, OP_VOID);
1273 tmp = SEXT40(ACC (OP[1]));
1274 if (tmp < 0)
1275 tmp = ~tmp & MASK40;
1276
1277 foo = 0x4000000000LL;
1278 for (i=1;i<25;i++)
1279 {
1280 if (tmp & foo)
1281 {
1282 SET_GPR (OP[0], i - 9);
1283 trace_output_16 (sd, i - 9);
1284 return;
1285 }
1286 foo >>= 1;
1287 }
1288 SET_GPR (OP[0], 16);
1289 trace_output_16 (sd, 16);
1290 }
1291
1292 /* jl */
1293 void
1294 OP_4D00 (SIM_DESC sd, SIM_CPU *cpu)
1295 {
1296 trace_input ("jl", OP_REG, OP_R0, OP_R1);
1297 SET_GPR (13, PC + 1);
1298 JMP (GPR (OP[0]));
1299 trace_output_void (sd);
1300 }
1301
1302 /* jmp */
1303 void
1304 OP_4C00 (SIM_DESC sd, SIM_CPU *cpu)
1305 {
1306 trace_input ("jmp", OP_REG,
1307 (OP[0] == 13) ? OP_R0 : OP_VOID,
1308 (OP[0] == 13) ? OP_R1 : OP_VOID);
1309
1310 JMP (GPR (OP[0]));
1311 trace_output_void (sd);
1312 }
1313
1314 /* ld */
1315 void
1316 OP_30000000 (SIM_DESC sd, SIM_CPU *cpu)
1317 {
1318 uint16 tmp;
1319 uint16 addr = OP[1] + GPR (OP[2]);
1320 trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID);
1321 if ((addr & 1))
1322 {
1323 trace_output_void (sd);
1324 EXCEPTION (SIM_SIGBUS);
1325 }
1326 tmp = RW (addr);
1327 SET_GPR (OP[0], tmp);
1328 trace_output_16 (sd, tmp);
1329 }
1330
1331 /* ld */
1332 void
1333 OP_6401 (SIM_DESC sd, SIM_CPU *cpu)
1334 {
1335 uint16 tmp;
1336 uint16 addr = GPR (OP[1]);
1337 trace_input ("ld", OP_REG_OUTPUT, OP_POSTDEC, OP_VOID);
1338 if ((addr & 1))
1339 {
1340 trace_output_void (sd);
1341 EXCEPTION (SIM_SIGBUS);
1342 }
1343 tmp = RW (addr);
1344 SET_GPR (OP[0], tmp);
1345 if (OP[0] != OP[1])
1346 INC_ADDR (OP[1], -2);
1347 trace_output_16 (sd, tmp);
1348 }
1349
1350 /* ld */
1351 void
1352 OP_6001 (SIM_DESC sd, SIM_CPU *cpu)
1353 {
1354 uint16 tmp;
1355 uint16 addr = GPR (OP[1]);
1356 trace_input ("ld", OP_REG_OUTPUT, OP_POSTINC, OP_VOID);
1357 if ((addr & 1))
1358 {
1359 trace_output_void (sd);
1360 EXCEPTION (SIM_SIGBUS);
1361 }
1362 tmp = RW (addr);
1363 SET_GPR (OP[0], tmp);
1364 if (OP[0] != OP[1])
1365 INC_ADDR (OP[1], 2);
1366 trace_output_16 (sd, tmp);
1367 }
1368
1369 /* ld */
1370 void
1371 OP_6000 (SIM_DESC sd, SIM_CPU *cpu)
1372 {
1373 uint16 tmp;
1374 uint16 addr = GPR (OP[1]);
1375 trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF, OP_VOID);
1376 if ((addr & 1))
1377 {
1378 trace_output_void (sd);
1379 EXCEPTION (SIM_SIGBUS);
1380 }
1381 tmp = RW (addr);
1382 SET_GPR (OP[0], tmp);
1383 trace_output_16 (sd, tmp);
1384 }
1385
1386 /* ld */
1387 void
1388 OP_32010000 (SIM_DESC sd, SIM_CPU *cpu)
1389 {
1390 uint16 tmp;
1391 uint16 addr = OP[1];
1392 trace_input ("ld", OP_REG_OUTPUT, OP_MEMREF3, OP_VOID);
1393 if ((addr & 1))
1394 {
1395 trace_output_void (sd);
1396 EXCEPTION (SIM_SIGBUS);
1397 }
1398 tmp = RW (addr);
1399 SET_GPR (OP[0], tmp);
1400 trace_output_16 (sd, tmp);
1401 }
1402
1403 /* ld2w */
1404 void
1405 OP_31000000 (SIM_DESC sd, SIM_CPU *cpu)
1406 {
1407 int32 tmp;
1408 uint16 addr = OP[1] + GPR (OP[2]);
1409 trace_input ("ld2w", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID);
1410 if ((addr & 1))
1411 {
1412 trace_output_void (sd);
1413 EXCEPTION (SIM_SIGBUS);
1414 }
1415 tmp = RLW (addr);
1416 SET_GPR32 (OP[0], tmp);
1417 trace_output_32 (sd, tmp);
1418 }
1419
1420 /* ld2w */
1421 void
1422 OP_6601 (SIM_DESC sd, SIM_CPU *cpu)
1423 {
1424 uint16 addr = GPR (OP[1]);
1425 int32 tmp;
1426 trace_input ("ld2w", OP_REG_OUTPUT, OP_POSTDEC, OP_VOID);
1427 if ((addr & 1))
1428 {
1429 trace_output_void (sd);
1430 EXCEPTION (SIM_SIGBUS);
1431 }
1432 tmp = RLW (addr);
1433 SET_GPR32 (OP[0], tmp);
1434 if (OP[0] != OP[1] && ((OP[0] + 1) != OP[1]))
1435 INC_ADDR (OP[1], -4);
1436 trace_output_32 (sd, tmp);
1437 }
1438
1439 /* ld2w */
1440 void
1441 OP_6201 (SIM_DESC sd, SIM_CPU *cpu)
1442 {
1443 int32 tmp;
1444 uint16 addr = GPR (OP[1]);
1445 trace_input ("ld2w", OP_REG_OUTPUT, OP_POSTINC, OP_VOID);
1446 if ((addr & 1))
1447 {
1448 trace_output_void (sd);
1449 EXCEPTION (SIM_SIGBUS);
1450 }
1451 tmp = RLW (addr);
1452 SET_GPR32 (OP[0], tmp);
1453 if (OP[0] != OP[1] && ((OP[0] + 1) != OP[1]))
1454 INC_ADDR (OP[1], 4);
1455 trace_output_32 (sd, tmp);
1456 }
1457
1458 /* ld2w */
1459 void
1460 OP_6200 (SIM_DESC sd, SIM_CPU *cpu)
1461 {
1462 uint16 addr = GPR (OP[1]);
1463 int32 tmp;
1464 trace_input ("ld2w", OP_REG_OUTPUT, OP_MEMREF, OP_VOID);
1465 if ((addr & 1))
1466 {
1467 trace_output_void (sd);
1468 EXCEPTION (SIM_SIGBUS);
1469 }
1470 tmp = RLW (addr);
1471 SET_GPR32 (OP[0], tmp);
1472 trace_output_32 (sd, tmp);
1473 }
1474
1475 /* ld2w */
1476 void
1477 OP_33010000 (SIM_DESC sd, SIM_CPU *cpu)
1478 {
1479 int32 tmp;
1480 uint16 addr = OP[1];
1481 trace_input ("ld2w", OP_REG_OUTPUT, OP_MEMREF3, OP_VOID);
1482 if ((addr & 1))
1483 {
1484 trace_output_void (sd);
1485 EXCEPTION (SIM_SIGBUS);
1486 }
1487 tmp = RLW (addr);
1488 SET_GPR32 (OP[0], tmp);
1489 trace_output_32 (sd, tmp);
1490 }
1491
1492 /* ldb */
1493 void
1494 OP_38000000 (SIM_DESC sd, SIM_CPU *cpu)
1495 {
1496 int16 tmp;
1497 trace_input ("ldb", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID);
1498 tmp = SEXT8 (RB (OP[1] + GPR (OP[2])));
1499 SET_GPR (OP[0], tmp);
1500 trace_output_16 (sd, tmp);
1501 }
1502
1503 /* ldb */
1504 void
1505 OP_7000 (SIM_DESC sd, SIM_CPU *cpu)
1506 {
1507 int16 tmp;
1508 trace_input ("ldb", OP_REG_OUTPUT, OP_MEMREF, OP_VOID);
1509 tmp = SEXT8 (RB (GPR (OP[1])));
1510 SET_GPR (OP[0], tmp);
1511 trace_output_16 (sd, tmp);
1512 }
1513
1514 /* ldi.s */
1515 void
1516 OP_4001 (SIM_DESC sd, SIM_CPU *cpu)
1517 {
1518 int16 tmp;
1519 trace_input ("ldi.s", OP_REG_OUTPUT, OP_CONSTANT4, OP_VOID);
1520 tmp = SEXT4 (OP[1]);
1521 SET_GPR (OP[0], tmp);
1522 trace_output_16 (sd, tmp);
1523 }
1524
1525 /* ldi.l */
1526 void
1527 OP_20000000 (SIM_DESC sd, SIM_CPU *cpu)
1528 {
1529 int16 tmp;
1530 trace_input ("ldi.l", OP_REG_OUTPUT, OP_CONSTANT16, OP_VOID);
1531 tmp = OP[1];
1532 SET_GPR (OP[0], tmp);
1533 trace_output_16 (sd, tmp);
1534 }
1535
1536 /* ldub */
1537 void
1538 OP_39000000 (SIM_DESC sd, SIM_CPU *cpu)
1539 {
1540 int16 tmp;
1541 trace_input ("ldub", OP_REG_OUTPUT, OP_MEMREF2, OP_VOID);
1542 tmp = RB (OP[1] + GPR (OP[2]));
1543 SET_GPR (OP[0], tmp);
1544 trace_output_16 (sd, tmp);
1545 }
1546
1547 /* ldub */
1548 void
1549 OP_7200 (SIM_DESC sd, SIM_CPU *cpu)
1550 {
1551 int16 tmp;
1552 trace_input ("ldub", OP_REG_OUTPUT, OP_MEMREF, OP_VOID);
1553 tmp = RB (GPR (OP[1]));
1554 SET_GPR (OP[0], tmp);
1555 trace_output_16 (sd, tmp);
1556 }
1557
1558 /* mac */
1559 void
1560 OP_2A00 (SIM_DESC sd, SIM_CPU *cpu)
1561 {
1562 int64 tmp;
1563
1564 trace_input ("mac", OP_ACCUM, OP_REG, OP_REG);
1565 tmp = SEXT40 ((int16)(GPR (OP[1])) * (int16)(GPR (OP[2])));
1566
1567 if (PSW_FX)
1568 tmp = SEXT40( (tmp << 1) & MASK40);
1569
1570 if (PSW_ST && tmp > SEXT40(MAX32))
1571 tmp = (MAX32);
1572
1573 tmp += SEXT40 (ACC (OP[0]));
1574 if (PSW_ST)
1575 {
1576 if (tmp > SEXT40(MAX32))
1577 tmp = (MAX32);
1578 else if (tmp < SEXT40(MIN32))
1579 tmp = (MIN32);
1580 else
1581 tmp = (tmp & MASK40);
1582 }
1583 else
1584 tmp = (tmp & MASK40);
1585 SET_ACC (OP[0], tmp);
1586 trace_output_40 (sd, tmp);
1587 }
1588
1589 /* macsu */
1590 void
1591 OP_1A00 (SIM_DESC sd, SIM_CPU *cpu)
1592 {
1593 int64 tmp;
1594
1595 trace_input ("macsu", OP_ACCUM, OP_REG, OP_REG);
1596 tmp = SEXT40 ((int16) GPR (OP[1]) * GPR (OP[2]));
1597 if (PSW_FX)
1598 tmp = SEXT40 ((tmp << 1) & MASK40);
1599 tmp = ((SEXT40 (ACC (OP[0])) + tmp) & MASK40);
1600 SET_ACC (OP[0], tmp);
1601 trace_output_40 (sd, tmp);
1602 }
1603
1604 /* macu */
1605 void
1606 OP_3A00 (SIM_DESC sd, SIM_CPU *cpu)
1607 {
1608 uint64 tmp;
1609 uint32 src1;
1610 uint32 src2;
1611
1612 trace_input ("macu", OP_ACCUM, OP_REG, OP_REG);
1613 src1 = (uint16) GPR (OP[1]);
1614 src2 = (uint16) GPR (OP[2]);
1615 tmp = src1 * src2;
1616 if (PSW_FX)
1617 tmp = (tmp << 1);
1618 tmp = ((ACC (OP[0]) + tmp) & MASK40);
1619 SET_ACC (OP[0], tmp);
1620 trace_output_40 (sd, tmp);
1621 }
1622
1623 /* max */
1624 void
1625 OP_2600 (SIM_DESC sd, SIM_CPU *cpu)
1626 {
1627 int16 tmp;
1628 trace_input ("max", OP_REG, OP_REG, OP_VOID);
1629 SET_PSW_F1 (PSW_F0);
1630 if ((int16) GPR (OP[1]) > (int16)GPR (OP[0]))
1631 {
1632 tmp = GPR (OP[1]);
1633 SET_PSW_F0 (1);
1634 }
1635 else
1636 {
1637 tmp = GPR (OP[0]);
1638 SET_PSW_F0 (0);
1639 }
1640 SET_GPR (OP[0], tmp);
1641 trace_output_16 (sd, tmp);
1642 }
1643
1644 /* max */
1645 void
1646 OP_3600 (SIM_DESC sd, SIM_CPU *cpu)
1647 {
1648 int64 tmp;
1649
1650 trace_input ("max", OP_ACCUM, OP_DREG, OP_VOID);
1651 SET_PSW_F1 (PSW_F0);
1652 tmp = SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1);
1653 if (tmp > SEXT40 (ACC (OP[0])))
1654 {
1655 tmp = (tmp & MASK40);
1656 SET_PSW_F0 (1);
1657 }
1658 else
1659 {
1660 tmp = ACC (OP[0]);
1661 SET_PSW_F0 (0);
1662 }
1663 SET_ACC (OP[0], tmp);
1664 trace_output_40 (sd, tmp);
1665 }
1666
1667 /* max */
1668 void
1669 OP_3602 (SIM_DESC sd, SIM_CPU *cpu)
1670 {
1671 int64 tmp;
1672 trace_input ("max", OP_ACCUM, OP_ACCUM, OP_VOID);
1673 SET_PSW_F1 (PSW_F0);
1674 if (SEXT40 (ACC (OP[1])) > SEXT40 (ACC (OP[0])))
1675 {
1676 tmp = ACC (OP[1]);
1677 SET_PSW_F0 (1);
1678 }
1679 else
1680 {
1681 tmp = ACC (OP[0]);
1682 SET_PSW_F0 (0);
1683 }
1684 SET_ACC (OP[0], tmp);
1685 trace_output_40 (sd, tmp);
1686 }
1687
1688
1689 /* min */
1690 void
1691 OP_2601 (SIM_DESC sd, SIM_CPU *cpu)
1692 {
1693 int16 tmp;
1694 trace_input ("min", OP_REG, OP_REG, OP_VOID);
1695 SET_PSW_F1 (PSW_F0);
1696 if ((int16)GPR (OP[1]) < (int16)GPR (OP[0]))
1697 {
1698 tmp = GPR (OP[1]);
1699 SET_PSW_F0 (1);
1700 }
1701 else
1702 {
1703 tmp = GPR (OP[0]);
1704 SET_PSW_F0 (0);
1705 }
1706 SET_GPR (OP[0], tmp);
1707 trace_output_16 (sd, tmp);
1708 }
1709
1710 /* min */
1711 void
1712 OP_3601 (SIM_DESC sd, SIM_CPU *cpu)
1713 {
1714 int64 tmp;
1715
1716 trace_input ("min", OP_ACCUM, OP_DREG, OP_VOID);
1717 SET_PSW_F1 (PSW_F0);
1718 tmp = SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1);
1719 if (tmp < SEXT40(ACC (OP[0])))
1720 {
1721 tmp = (tmp & MASK40);
1722 SET_PSW_F0 (1);
1723 }
1724 else
1725 {
1726 tmp = ACC (OP[0]);
1727 SET_PSW_F0 (0);
1728 }
1729 SET_ACC (OP[0], tmp);
1730 trace_output_40 (sd, tmp);
1731 }
1732
1733 /* min */
1734 void
1735 OP_3603 (SIM_DESC sd, SIM_CPU *cpu)
1736 {
1737 int64 tmp;
1738 trace_input ("min", OP_ACCUM, OP_ACCUM, OP_VOID);
1739 SET_PSW_F1 (PSW_F0);
1740 if (SEXT40(ACC (OP[1])) < SEXT40(ACC (OP[0])))
1741 {
1742 tmp = ACC (OP[1]);
1743 SET_PSW_F0 (1);
1744 }
1745 else
1746 {
1747 tmp = ACC (OP[0]);
1748 SET_PSW_F0 (0);
1749 }
1750 SET_ACC (OP[0], tmp);
1751 trace_output_40 (sd, tmp);
1752 }
1753
1754 /* msb */
1755 void
1756 OP_2800 (SIM_DESC sd, SIM_CPU *cpu)
1757 {
1758 int64 tmp;
1759
1760 trace_input ("msb", OP_ACCUM, OP_REG, OP_REG);
1761 tmp = SEXT40 ((int16)(GPR (OP[1])) * (int16)(GPR (OP[2])));
1762
1763 if (PSW_FX)
1764 tmp = SEXT40 ((tmp << 1) & MASK40);
1765
1766 if (PSW_ST && tmp > SEXT40(MAX32))
1767 tmp = (MAX32);
1768
1769 tmp = SEXT40(ACC (OP[0])) - tmp;
1770 if (PSW_ST)
1771 {
1772 if (tmp > SEXT40(MAX32))
1773 tmp = (MAX32);
1774 else if (tmp < SEXT40(MIN32))
1775 tmp = (MIN32);
1776 else
1777 tmp = (tmp & MASK40);
1778 }
1779 else
1780 {
1781 tmp = (tmp & MASK40);
1782 }
1783 SET_ACC (OP[0], tmp);
1784 trace_output_40 (sd, tmp);
1785 }
1786
1787 /* msbsu */
1788 void
1789 OP_1800 (SIM_DESC sd, SIM_CPU *cpu)
1790 {
1791 int64 tmp;
1792
1793 trace_input ("msbsu", OP_ACCUM, OP_REG, OP_REG);
1794 tmp = SEXT40 ((int16)GPR (OP[1]) * GPR (OP[2]));
1795 if (PSW_FX)
1796 tmp = SEXT40( (tmp << 1) & MASK40);
1797 tmp = ((SEXT40 (ACC (OP[0])) - tmp) & MASK40);
1798 SET_ACC (OP[0], tmp);
1799 trace_output_40 (sd, tmp);
1800 }
1801
1802 /* msbu */
1803 void
1804 OP_3800 (SIM_DESC sd, SIM_CPU *cpu)
1805 {
1806 uint64 tmp;
1807 uint32 src1;
1808 uint32 src2;
1809
1810 trace_input ("msbu", OP_ACCUM, OP_REG, OP_REG);
1811 src1 = (uint16) GPR (OP[1]);
1812 src2 = (uint16) GPR (OP[2]);
1813 tmp = src1 * src2;
1814 if (PSW_FX)
1815 tmp = (tmp << 1);
1816 tmp = ((ACC (OP[0]) - tmp) & MASK40);
1817 SET_ACC (OP[0], tmp);
1818 trace_output_40 (sd, tmp);
1819 }
1820
1821 /* mul */
1822 void
1823 OP_2E00 (SIM_DESC sd, SIM_CPU *cpu)
1824 {
1825 int16 tmp;
1826 trace_input ("mul", OP_REG, OP_REG, OP_VOID);
1827 tmp = GPR (OP[0]) * GPR (OP[1]);
1828 SET_GPR (OP[0], tmp);
1829 trace_output_16 (sd, tmp);
1830 }
1831
1832 /* mulx */
1833 void
1834 OP_2C00 (SIM_DESC sd, SIM_CPU *cpu)
1835 {
1836 int64 tmp;
1837
1838 trace_input ("mulx", OP_ACCUM_OUTPUT, OP_REG, OP_REG);
1839 tmp = SEXT40 ((int16)(GPR (OP[1])) * (int16)(GPR (OP[2])));
1840
1841 if (PSW_FX)
1842 tmp = SEXT40 ((tmp << 1) & MASK40);
1843
1844 if (PSW_ST && tmp > SEXT40(MAX32))
1845 tmp = (MAX32);
1846 else
1847 tmp = (tmp & MASK40);
1848 SET_ACC (OP[0], tmp);
1849 trace_output_40 (sd, tmp);
1850 }
1851
1852 /* mulxsu */
1853 void
1854 OP_1C00 (SIM_DESC sd, SIM_CPU *cpu)
1855 {
1856 int64 tmp;
1857
1858 trace_input ("mulxsu", OP_ACCUM_OUTPUT, OP_REG, OP_REG);
1859 tmp = SEXT40 ((int16)(GPR (OP[1])) * GPR (OP[2]));
1860
1861 if (PSW_FX)
1862 tmp <<= 1;
1863 tmp = (tmp & MASK40);
1864 SET_ACC (OP[0], tmp);
1865 trace_output_40 (sd, tmp);
1866 }
1867
1868 /* mulxu */
1869 void
1870 OP_3C00 (SIM_DESC sd, SIM_CPU *cpu)
1871 {
1872 uint64 tmp;
1873 uint32 src1;
1874 uint32 src2;
1875
1876 trace_input ("mulxu", OP_ACCUM_OUTPUT, OP_REG, OP_REG);
1877 src1 = (uint16) GPR (OP[1]);
1878 src2 = (uint16) GPR (OP[2]);
1879 tmp = src1 * src2;
1880 if (PSW_FX)
1881 tmp <<= 1;
1882 tmp = (tmp & MASK40);
1883 SET_ACC (OP[0], tmp);
1884 trace_output_40 (sd, tmp);
1885 }
1886
1887 /* mv */
1888 void
1889 OP_4000 (SIM_DESC sd, SIM_CPU *cpu)
1890 {
1891 int16 tmp;
1892 trace_input ("mv", OP_REG_OUTPUT, OP_REG, OP_VOID);
1893 tmp = GPR (OP[1]);
1894 SET_GPR (OP[0], tmp);
1895 trace_output_16 (sd, tmp);
1896 }
1897
1898 /* mv2w */
1899 void
1900 OP_5000 (SIM_DESC sd, SIM_CPU *cpu)
1901 {
1902 int32 tmp;
1903 trace_input ("mv2w", OP_DREG_OUTPUT, OP_DREG, OP_VOID);
1904 tmp = GPR32 (OP[1]);
1905 SET_GPR32 (OP[0], tmp);
1906 trace_output_32 (sd, tmp);
1907 }
1908
1909 /* mv2wfac */
1910 void
1911 OP_3E00 (SIM_DESC sd, SIM_CPU *cpu)
1912 {
1913 int32 tmp;
1914 trace_input ("mv2wfac", OP_DREG_OUTPUT, OP_ACCUM, OP_VOID);
1915 tmp = ACC (OP[1]);
1916 SET_GPR32 (OP[0], tmp);
1917 trace_output_32 (sd, tmp);
1918 }
1919
1920 /* mv2wtac */
1921 void
1922 OP_3E01 (SIM_DESC sd, SIM_CPU *cpu)
1923 {
1924 int64 tmp;
1925 trace_input ("mv2wtac", OP_DREG, OP_ACCUM_OUTPUT, OP_VOID);
1926 tmp = ((SEXT16 (GPR (OP[0])) << 16 | GPR (OP[0] + 1)) & MASK40);
1927 SET_ACC (OP[1], tmp);
1928 trace_output_40 (sd, tmp);
1929 }
1930
1931 /* mvac */
1932 void
1933 OP_3E03 (SIM_DESC sd, SIM_CPU *cpu)
1934 {
1935 int64 tmp;
1936 trace_input ("mvac", OP_ACCUM_OUTPUT, OP_ACCUM, OP_VOID);
1937 tmp = ACC (OP[1]);
1938 SET_ACC (OP[0], tmp);
1939 trace_output_40 (sd, tmp);
1940 }
1941
1942 /* mvb */
1943 void
1944 OP_5400 (SIM_DESC sd, SIM_CPU *cpu)
1945 {
1946 int16 tmp;
1947 trace_input ("mvb", OP_REG_OUTPUT, OP_REG, OP_VOID);
1948 tmp = SEXT8 (GPR (OP[1]) & 0xff);
1949 SET_GPR (OP[0], tmp);
1950 trace_output_16 (sd, tmp);
1951 }
1952
1953 /* mvf0f */
1954 void
1955 OP_4400 (SIM_DESC sd, SIM_CPU *cpu)
1956 {
1957 int16 tmp;
1958 trace_input ("mvf0f", OP_REG_OUTPUT, OP_REG, OP_VOID);
1959 if (PSW_F0 == 0)
1960 {
1961 tmp = GPR (OP[1]);
1962 SET_GPR (OP[0], tmp);
1963 }
1964 else
1965 tmp = GPR (OP[0]);
1966 trace_output_16 (sd, tmp);
1967 }
1968
1969 /* mvf0t */
1970 void
1971 OP_4401 (SIM_DESC sd, SIM_CPU *cpu)
1972 {
1973 int16 tmp;
1974 trace_input ("mvf0t", OP_REG_OUTPUT, OP_REG, OP_VOID);
1975 if (PSW_F0)
1976 {
1977 tmp = GPR (OP[1]);
1978 SET_GPR (OP[0], tmp);
1979 }
1980 else
1981 tmp = GPR (OP[0]);
1982 trace_output_16 (sd, tmp);
1983 }
1984
1985 /* mvfacg */
1986 void
1987 OP_1E04 (SIM_DESC sd, SIM_CPU *cpu)
1988 {
1989 int16 tmp;
1990 trace_input ("mvfacg", OP_REG_OUTPUT, OP_ACCUM, OP_VOID);
1991 tmp = ((ACC (OP[1]) >> 32) & 0xff);
1992 SET_GPR (OP[0], tmp);
1993 trace_output_16 (sd, tmp);
1994 }
1995
1996 /* mvfachi */
1997 void
1998 OP_1E00 (SIM_DESC sd, SIM_CPU *cpu)
1999 {
2000 int16 tmp;
2001 trace_input ("mvfachi", OP_REG_OUTPUT, OP_ACCUM, OP_VOID);
2002 tmp = (ACC (OP[1]) >> 16);
2003 SET_GPR (OP[0], tmp);
2004 trace_output_16 (sd, tmp);
2005 }
2006
2007 /* mvfaclo */
2008 void
2009 OP_1E02 (SIM_DESC sd, SIM_CPU *cpu)
2010 {
2011 int16 tmp;
2012 trace_input ("mvfaclo", OP_REG_OUTPUT, OP_ACCUM, OP_VOID);
2013 tmp = ACC (OP[1]);
2014 SET_GPR (OP[0], tmp);
2015 trace_output_16 (sd, tmp);
2016 }
2017
2018 /* mvfc */
2019 void
2020 OP_5200 (SIM_DESC sd, SIM_CPU *cpu)
2021 {
2022 int16 tmp;
2023 trace_input ("mvfc", OP_REG_OUTPUT, OP_CR, OP_VOID);
2024 tmp = CREG (OP[1]);
2025 SET_GPR (OP[0], tmp);
2026 trace_output_16 (sd, tmp);
2027 }
2028
2029 /* mvtacg */
2030 void
2031 OP_1E41 (SIM_DESC sd, SIM_CPU *cpu)
2032 {
2033 int64 tmp;
2034 trace_input ("mvtacg", OP_REG, OP_ACCUM, OP_VOID);
2035 tmp = ((ACC (OP[1]) & MASK32)
2036 | ((int64)(GPR (OP[0]) & 0xff) << 32));
2037 SET_ACC (OP[1], tmp);
2038 trace_output_40 (sd, tmp);
2039 }
2040
2041 /* mvtachi */
2042 void
2043 OP_1E01 (SIM_DESC sd, SIM_CPU *cpu)
2044 {
2045 uint64 tmp;
2046 trace_input ("mvtachi", OP_REG, OP_ACCUM, OP_VOID);
2047 tmp = ACC (OP[1]) & 0xffff;
2048 tmp = ((SEXT16 (GPR (OP[0])) << 16 | tmp) & MASK40);
2049 SET_ACC (OP[1], tmp);
2050 trace_output_40 (sd, tmp);
2051 }
2052
2053 /* mvtaclo */
2054 void
2055 OP_1E21 (SIM_DESC sd, SIM_CPU *cpu)
2056 {
2057 int64 tmp;
2058 trace_input ("mvtaclo", OP_REG, OP_ACCUM, OP_VOID);
2059 tmp = ((SEXT16 (GPR (OP[0]))) & MASK40);
2060 SET_ACC (OP[1], tmp);
2061 trace_output_40 (sd, tmp);
2062 }
2063
2064 /* mvtc */
2065 void
2066 OP_5600 (SIM_DESC sd, SIM_CPU *cpu)
2067 {
2068 int16 tmp;
2069 trace_input ("mvtc", OP_REG, OP_CR_OUTPUT, OP_VOID);
2070 tmp = GPR (OP[0]);
2071 tmp = SET_CREG (OP[1], tmp);
2072 trace_output_16 (sd, tmp);
2073 }
2074
2075 /* mvub */
2076 void
2077 OP_5401 (SIM_DESC sd, SIM_CPU *cpu)
2078 {
2079 int16 tmp;
2080 trace_input ("mvub", OP_REG_OUTPUT, OP_REG, OP_VOID);
2081 tmp = (GPR (OP[1]) & 0xff);
2082 SET_GPR (OP[0], tmp);
2083 trace_output_16 (sd, tmp);
2084 }
2085
2086 /* neg */
2087 void
2088 OP_4605 (SIM_DESC sd, SIM_CPU *cpu)
2089 {
2090 int16 tmp;
2091 trace_input ("neg", OP_REG, OP_VOID, OP_VOID);
2092 tmp = - GPR (OP[0]);
2093 SET_GPR (OP[0], tmp);
2094 trace_output_16 (sd, tmp);
2095 }
2096
2097 /* neg */
2098 void
2099 OP_5605 (SIM_DESC sd, SIM_CPU *cpu)
2100 {
2101 int64 tmp;
2102
2103 trace_input ("neg", OP_ACCUM, OP_VOID, OP_VOID);
2104 tmp = -SEXT40(ACC (OP[0]));
2105 if (PSW_ST)
2106 {
2107 if (tmp > SEXT40(MAX32))
2108 tmp = (MAX32);
2109 else if (tmp < SEXT40(MIN32))
2110 tmp = (MIN32);
2111 else
2112 tmp = (tmp & MASK40);
2113 }
2114 else
2115 tmp = (tmp & MASK40);
2116 SET_ACC (OP[0], tmp);
2117 trace_output_40 (sd, tmp);
2118 }
2119
2120
2121 /* nop */
2122 void
2123 OP_5E00 (SIM_DESC sd, SIM_CPU *cpu)
2124 {
2125 trace_input ("nop", OP_VOID, OP_VOID, OP_VOID);
2126
2127 ins_type_counters[ (int)State.ins_type ]--; /* don't count nops as normal instructions */
2128 switch (State.ins_type)
2129 {
2130 default:
2131 ins_type_counters[ (int)INS_UNKNOWN ]++;
2132 break;
2133
2134 case INS_LEFT_PARALLEL:
2135 /* Don't count a parallel op that includes a NOP as a true parallel op */
2136 ins_type_counters[ (int)INS_RIGHT_PARALLEL ]--;
2137 ins_type_counters[ (int)INS_RIGHT ]++;
2138 ins_type_counters[ (int)INS_LEFT_NOPS ]++;
2139 break;
2140
2141 case INS_LEFT:
2142 case INS_LEFT_COND_EXE:
2143 ins_type_counters[ (int)INS_LEFT_NOPS ]++;
2144 break;
2145
2146 case INS_RIGHT_PARALLEL:
2147 /* Don't count a parallel op that includes a NOP as a true parallel op */
2148 ins_type_counters[ (int)INS_LEFT_PARALLEL ]--;
2149 ins_type_counters[ (int)INS_LEFT ]++;
2150 ins_type_counters[ (int)INS_RIGHT_NOPS ]++;
2151 break;
2152
2153 case INS_RIGHT:
2154 case INS_RIGHT_COND_EXE:
2155 ins_type_counters[ (int)INS_RIGHT_NOPS ]++;
2156 break;
2157 }
2158
2159 trace_output_void (sd);
2160 }
2161
2162 /* not */
2163 void
2164 OP_4603 (SIM_DESC sd, SIM_CPU *cpu)
2165 {
2166 int16 tmp;
2167 trace_input ("not", OP_REG, OP_VOID, OP_VOID);
2168 tmp = ~GPR (OP[0]);
2169 SET_GPR (OP[0], tmp);
2170 trace_output_16 (sd, tmp);
2171 }
2172
2173 /* or */
2174 void
2175 OP_800 (SIM_DESC sd, SIM_CPU *cpu)
2176 {
2177 int16 tmp;
2178 trace_input ("or", OP_REG, OP_REG, OP_VOID);
2179 tmp = (GPR (OP[0]) | GPR (OP[1]));
2180 SET_GPR (OP[0], tmp);
2181 trace_output_16 (sd, tmp);
2182 }
2183
2184 /* or3 */
2185 void
2186 OP_4000000 (SIM_DESC sd, SIM_CPU *cpu)
2187 {
2188 int16 tmp;
2189 trace_input ("or3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16);
2190 tmp = (GPR (OP[1]) | OP[2]);
2191 SET_GPR (OP[0], tmp);
2192 trace_output_16 (sd, tmp);
2193 }
2194
2195 /* rac */
2196 void
2197 OP_5201 (SIM_DESC sd, SIM_CPU *cpu)
2198 {
2199 int64 tmp;
2200 int shift = SEXT3 (OP[2]);
2201
2202 trace_input ("rac", OP_DREG_OUTPUT, OP_ACCUM, OP_CONSTANT3);
2203 if (OP[1] != 0)
2204 {
2205 sim_io_printf (sd,
2206 "ERROR at PC 0x%x: instruction only valid for A0\n",
2207 PC<<2);
2208 EXCEPTION (SIM_SIGILL);
2209 }
2210
2211 SET_PSW_F1 (PSW_F0);
2212 tmp = SEXT56 ((ACC (0) << 16) | (ACC (1) & 0xffff));
2213 if (shift >=0)
2214 tmp <<= shift;
2215 else
2216 tmp >>= -shift;
2217 tmp += 0x8000;
2218 tmp >>= 16; /* look at bits 0:43 */
2219 if (tmp > SEXT44 (SIGNED64 (0x0007fffffff)))
2220 {
2221 tmp = 0x7fffffff;
2222 SET_PSW_F0 (1);
2223 }
2224 else if (tmp < SEXT44 (SIGNED64 (0xfff80000000)))
2225 {
2226 tmp = 0x80000000;
2227 SET_PSW_F0 (1);
2228 }
2229 else
2230 {
2231 SET_PSW_F0 (0);
2232 }
2233 SET_GPR32 (OP[0], tmp);
2234 trace_output_32 (sd, tmp);
2235 }
2236
2237 /* rachi */
2238 void
2239 OP_4201 (SIM_DESC sd, SIM_CPU *cpu)
2240 {
2241 signed64 tmp;
2242 int shift = SEXT3 (OP[2]);
2243
2244 trace_input ("rachi", OP_REG_OUTPUT, OP_ACCUM, OP_CONSTANT3);
2245 SET_PSW_F1 (PSW_F0);
2246 if (shift >=0)
2247 tmp = SEXT40 (ACC (OP[1])) << shift;
2248 else
2249 tmp = SEXT40 (ACC (OP[1])) >> -shift;
2250 tmp += 0x8000;
2251
2252 if (tmp > SEXT44 (SIGNED64 (0x0007fffffff)))
2253 {
2254 tmp = 0x7fff;
2255 SET_PSW_F0 (1);
2256 }
2257 else if (tmp < SEXT44 (SIGNED64 (0xfff80000000)))
2258 {
2259 tmp = 0x8000;
2260 SET_PSW_F0 (1);
2261 }
2262 else
2263 {
2264 tmp = (tmp >> 16);
2265 SET_PSW_F0 (0);
2266 }
2267 SET_GPR (OP[0], tmp);
2268 trace_output_16 (sd, tmp);
2269 }
2270
2271 /* rep */
2272 void
2273 OP_27000000 (SIM_DESC sd, SIM_CPU *cpu)
2274 {
2275 trace_input ("rep", OP_REG, OP_CONSTANT16, OP_VOID);
2276 SET_RPT_S (PC + 1);
2277 SET_RPT_E (PC + OP[1]);
2278 SET_RPT_C (GPR (OP[0]));
2279 SET_PSW_RP (1);
2280 if (GPR (OP[0]) == 0)
2281 {
2282 sim_io_printf (sd, "ERROR: rep with count=0 is illegal.\n");
2283 EXCEPTION (SIM_SIGILL);
2284 }
2285 if (OP[1] < 4)
2286 {
2287 sim_io_printf (sd, "ERROR: rep must include at least 4 instructions.\n");
2288 EXCEPTION (SIM_SIGILL);
2289 }
2290 trace_output_void (sd);
2291 }
2292
2293 /* repi */
2294 void
2295 OP_2F000000 (SIM_DESC sd, SIM_CPU *cpu)
2296 {
2297 trace_input ("repi", OP_CONSTANT16, OP_CONSTANT16, OP_VOID);
2298 SET_RPT_S (PC + 1);
2299 SET_RPT_E (PC + OP[1]);
2300 SET_RPT_C (OP[0]);
2301 SET_PSW_RP (1);
2302 if (OP[0] == 0)
2303 {
2304 sim_io_printf (sd, "ERROR: repi with count=0 is illegal.\n");
2305 EXCEPTION (SIM_SIGILL);
2306 }
2307 if (OP[1] < 4)
2308 {
2309 sim_io_printf (sd, "ERROR: repi must include at least 4 instructions.\n");
2310 EXCEPTION (SIM_SIGILL);
2311 }
2312 trace_output_void (sd);
2313 }
2314
2315 /* rtd */
2316 void
2317 OP_5F60 (SIM_DESC sd, SIM_CPU *cpu)
2318 {
2319 trace_input ("rtd", OP_VOID, OP_VOID, OP_VOID);
2320 SET_CREG (PSW_CR, DPSW);
2321 JMP(DPC);
2322 trace_output_void (sd);
2323 }
2324
2325 /* rte */
2326 void
2327 OP_5F40 (SIM_DESC sd, SIM_CPU *cpu)
2328 {
2329 trace_input ("rte", OP_VOID, OP_VOID, OP_VOID);
2330 SET_CREG (PSW_CR, BPSW);
2331 JMP(BPC);
2332 trace_output_void (sd);
2333 }
2334
2335 /* sac */
2336 void OP_5209 (SIM_DESC sd, SIM_CPU *cpu)
2337 {
2338 int64 tmp;
2339
2340 trace_input ("sac", OP_REG_OUTPUT, OP_ACCUM, OP_VOID);
2341
2342 tmp = SEXT40(ACC (OP[1]));
2343
2344 SET_PSW_F1 (PSW_F0);
2345
2346 if (tmp > SEXT40(MAX32))
2347 {
2348 tmp = (MAX32);
2349 SET_PSW_F0 (1);
2350 }
2351 else if (tmp < SEXT40(MIN32))
2352 {
2353 tmp = 0x80000000;
2354 SET_PSW_F0 (1);
2355 }
2356 else
2357 {
2358 tmp = (tmp & MASK32);
2359 SET_PSW_F0 (0);
2360 }
2361
2362 SET_GPR32 (OP[0], tmp);
2363
2364 trace_output_40 (sd, tmp);
2365 }
2366
2367 /* sachi */
2368 void
2369 OP_4209 (SIM_DESC sd, SIM_CPU *cpu)
2370 {
2371 int64 tmp;
2372
2373 trace_input ("sachi", OP_REG_OUTPUT, OP_ACCUM, OP_VOID);
2374
2375 tmp = SEXT40(ACC (OP[1]));
2376
2377 SET_PSW_F1 (PSW_F0);
2378
2379 if (tmp > SEXT40(MAX32))
2380 {
2381 tmp = 0x7fff;
2382 SET_PSW_F0 (1);
2383 }
2384 else if (tmp < SEXT40(MIN32))
2385 {
2386 tmp = 0x8000;
2387 SET_PSW_F0 (1);
2388 }
2389 else
2390 {
2391 tmp >>= 16;
2392 SET_PSW_F0 (0);
2393 }
2394
2395 SET_GPR (OP[0], tmp);
2396
2397 trace_output_16 (sd, OP[0]);
2398 }
2399
2400 /* sadd */
2401 void
2402 OP_1223 (SIM_DESC sd, SIM_CPU *cpu)
2403 {
2404 int64 tmp;
2405
2406 trace_input ("sadd", OP_ACCUM, OP_ACCUM, OP_VOID);
2407 tmp = SEXT40(ACC (OP[0])) + (SEXT40(ACC (OP[1])) >> 16);
2408 if (PSW_ST)
2409 {
2410 if (tmp > SEXT40(MAX32))
2411 tmp = (MAX32);
2412 else if (tmp < SEXT40(MIN32))
2413 tmp = (MIN32);
2414 else
2415 tmp = (tmp & MASK40);
2416 }
2417 else
2418 tmp = (tmp & MASK40);
2419 SET_ACC (OP[0], tmp);
2420 trace_output_40 (sd, tmp);
2421 }
2422
2423 /* setf0f */
2424 void
2425 OP_4611 (SIM_DESC sd, SIM_CPU *cpu)
2426 {
2427 int16 tmp;
2428 trace_input ("setf0f", OP_REG_OUTPUT, OP_VOID, OP_VOID);
2429 tmp = ((PSW_F0 == 0) ? 1 : 0);
2430 SET_GPR (OP[0], tmp);
2431 trace_output_16 (sd, tmp);
2432 }
2433
2434 /* setf0t */
2435 void
2436 OP_4613 (SIM_DESC sd, SIM_CPU *cpu)
2437 {
2438 int16 tmp;
2439 trace_input ("setf0t", OP_REG_OUTPUT, OP_VOID, OP_VOID);
2440 tmp = ((PSW_F0 == 1) ? 1 : 0);
2441 SET_GPR (OP[0], tmp);
2442 trace_output_16 (sd, tmp);
2443 }
2444
2445 /* slae */
2446 void
2447 OP_3220 (SIM_DESC sd, SIM_CPU *cpu)
2448 {
2449 int64 tmp;
2450 int16 reg;
2451
2452 trace_input ("slae", OP_ACCUM, OP_REG, OP_VOID);
2453
2454 reg = SEXT16 (GPR (OP[1]));
2455
2456 if (reg >= 17 || reg <= -17)
2457 {
2458 sim_io_printf (sd, "ERROR: shift value %d too large.\n", reg);
2459 EXCEPTION (SIM_SIGILL);
2460 }
2461
2462 tmp = SEXT40 (ACC (OP[0]));
2463
2464 if (PSW_ST && (tmp < SEXT40 (MIN32) || tmp > SEXT40 (MAX32)))
2465 {
2466 sim_io_printf (sd, "ERROR: accumulator value 0x%.2x%.8lx out of range\n", ((int)(tmp >> 32) & 0xff), ((unsigned long) tmp) & 0xffffffff);
2467 EXCEPTION (SIM_SIGILL);
2468 }
2469
2470 if (reg >= 0 && reg <= 16)
2471 {
2472 tmp = SEXT56 ((SEXT56 (tmp)) << (GPR (OP[1])));
2473 if (PSW_ST)
2474 {
2475 if (tmp > SEXT40(MAX32))
2476 tmp = (MAX32);
2477 else if (tmp < SEXT40(MIN32))
2478 tmp = (MIN32);
2479 else
2480 tmp = (tmp & MASK40);
2481 }
2482 else
2483 tmp = (tmp & MASK40);
2484 }
2485 else
2486 {
2487 tmp = (SEXT40 (ACC (OP[0]))) >> (-GPR (OP[1]));
2488 }
2489
2490 SET_ACC(OP[0], tmp);
2491
2492 trace_output_40 (sd, tmp);
2493 }
2494
2495 /* sleep */
2496 void
2497 OP_5FC0 (SIM_DESC sd, SIM_CPU *cpu)
2498 {
2499 trace_input ("sleep", OP_VOID, OP_VOID, OP_VOID);
2500 SET_PSW_IE (1);
2501 trace_output_void (sd);
2502 }
2503
2504 /* sll */
2505 void
2506 OP_2200 (SIM_DESC sd, SIM_CPU *cpu)
2507 {
2508 int16 tmp;
2509 trace_input ("sll", OP_REG, OP_REG, OP_VOID);
2510 tmp = (GPR (OP[0]) << (GPR (OP[1]) & 0xf));
2511 SET_GPR (OP[0], tmp);
2512 trace_output_16 (sd, tmp);
2513 }
2514
2515 /* sll */
2516 void
2517 OP_3200 (SIM_DESC sd, SIM_CPU *cpu)
2518 {
2519 int64 tmp;
2520 trace_input ("sll", OP_ACCUM, OP_REG, OP_VOID);
2521 if ((GPR (OP[1]) & 31) <= 16)
2522 tmp = SEXT40 (ACC (OP[0])) << (GPR (OP[1]) & 31);
2523 else
2524 {
2525 sim_io_printf (sd, "ERROR: shift value %d too large.\n", GPR (OP[1]) & 31);
2526 EXCEPTION (SIM_SIGILL);
2527 }
2528
2529 if (PSW_ST)
2530 {
2531 if (tmp > SEXT40(MAX32))
2532 tmp = (MAX32);
2533 else if (tmp < SEXT40(MIN32))
2534 tmp = (MIN32);
2535 else
2536 tmp = (tmp & MASK40);
2537 }
2538 else
2539 tmp = (tmp & MASK40);
2540 SET_ACC (OP[0], tmp);
2541 trace_output_40 (sd, tmp);
2542 }
2543
2544 /* slli */
2545 void
2546 OP_2201 (SIM_DESC sd, SIM_CPU *cpu)
2547 {
2548 int16 tmp;
2549 trace_input ("slli", OP_REG, OP_CONSTANT16, OP_VOID);
2550 tmp = (GPR (OP[0]) << OP[1]);
2551 SET_GPR (OP[0], tmp);
2552 trace_output_16 (sd, tmp);
2553 }
2554
2555 /* slli */
2556 void
2557 OP_3201 (SIM_DESC sd, SIM_CPU *cpu)
2558 {
2559 int64 tmp;
2560
2561 if (OP[1] == 0)
2562 OP[1] = 16;
2563
2564 trace_input ("slli", OP_ACCUM, OP_CONSTANT16, OP_VOID);
2565 tmp = SEXT40(ACC (OP[0])) << OP[1];
2566
2567 if (PSW_ST)
2568 {
2569 if (tmp > SEXT40(MAX32))
2570 tmp = (MAX32);
2571 else if (tmp < SEXT40(MIN32))
2572 tmp = (MIN32);
2573 else
2574 tmp = (tmp & MASK40);
2575 }
2576 else
2577 tmp = (tmp & MASK40);
2578 SET_ACC (OP[0], tmp);
2579 trace_output_40 (sd, tmp);
2580 }
2581
2582 /* slx */
2583 void
2584 OP_460B (SIM_DESC sd, SIM_CPU *cpu)
2585 {
2586 int16 tmp;
2587 trace_input ("slx", OP_REG, OP_VOID, OP_VOID);
2588 tmp = ((GPR (OP[0]) << 1) | PSW_F0);
2589 SET_GPR (OP[0], tmp);
2590 trace_output_16 (sd, tmp);
2591 }
2592
2593 /* sra */
2594 void
2595 OP_2400 (SIM_DESC sd, SIM_CPU *cpu)
2596 {
2597 int16 tmp;
2598 trace_input ("sra", OP_REG, OP_REG, OP_VOID);
2599 tmp = (((int16)(GPR (OP[0]))) >> (GPR (OP[1]) & 0xf));
2600 SET_GPR (OP[0], tmp);
2601 trace_output_16 (sd, tmp);
2602 }
2603
2604 /* sra */
2605 void
2606 OP_3400 (SIM_DESC sd, SIM_CPU *cpu)
2607 {
2608 trace_input ("sra", OP_ACCUM, OP_REG, OP_VOID);
2609 if ((GPR (OP[1]) & 31) <= 16)
2610 {
2611 int64 tmp = ((SEXT40(ACC (OP[0])) >> (GPR (OP[1]) & 31)) & MASK40);
2612 SET_ACC (OP[0], tmp);
2613 trace_output_40 (sd, tmp);
2614 }
2615 else
2616 {
2617 sim_io_printf (sd, "ERROR: shift value %d too large.\n", GPR (OP[1]) & 31);
2618 EXCEPTION (SIM_SIGILL);
2619 }
2620 }
2621
2622 /* srai */
2623 void
2624 OP_2401 (SIM_DESC sd, SIM_CPU *cpu)
2625 {
2626 int16 tmp;
2627 trace_input ("srai", OP_REG, OP_CONSTANT16, OP_VOID);
2628 tmp = (((int16)(GPR (OP[0]))) >> OP[1]);
2629 SET_GPR (OP[0], tmp);
2630 trace_output_16 (sd, tmp);
2631 }
2632
2633 /* srai */
2634 void
2635 OP_3401 (SIM_DESC sd, SIM_CPU *cpu)
2636 {
2637 int64 tmp;
2638 if (OP[1] == 0)
2639 OP[1] = 16;
2640
2641 trace_input ("srai", OP_ACCUM, OP_CONSTANT16, OP_VOID);
2642 tmp = ((SEXT40(ACC (OP[0])) >> OP[1]) & MASK40);
2643 SET_ACC (OP[0], tmp);
2644 trace_output_40 (sd, tmp);
2645 }
2646
2647 /* srl */
2648 void
2649 OP_2000 (SIM_DESC sd, SIM_CPU *cpu)
2650 {
2651 int16 tmp;
2652 trace_input ("srl", OP_REG, OP_REG, OP_VOID);
2653 tmp = (GPR (OP[0]) >> (GPR (OP[1]) & 0xf));
2654 SET_GPR (OP[0], tmp);
2655 trace_output_16 (sd, tmp);
2656 }
2657
2658 /* srl */
2659 void
2660 OP_3000 (SIM_DESC sd, SIM_CPU *cpu)
2661 {
2662 trace_input ("srl", OP_ACCUM, OP_REG, OP_VOID);
2663 if ((GPR (OP[1]) & 31) <= 16)
2664 {
2665 int64 tmp = ((uint64)((ACC (OP[0]) & MASK40) >> (GPR (OP[1]) & 31)));
2666 SET_ACC (OP[0], tmp);
2667 trace_output_40 (sd, tmp);
2668 }
2669 else
2670 {
2671 sim_io_printf (sd, "ERROR: shift value %d too large.\n", GPR (OP[1]) & 31);
2672 EXCEPTION (SIM_SIGILL);
2673 }
2674
2675 }
2676
2677 /* srli */
2678 void
2679 OP_2001 (SIM_DESC sd, SIM_CPU *cpu)
2680 {
2681 int16 tmp;
2682 trace_input ("srli", OP_REG, OP_CONSTANT16, OP_VOID);
2683 tmp = (GPR (OP[0]) >> OP[1]);
2684 SET_GPR (OP[0], tmp);
2685 trace_output_16 (sd, tmp);
2686 }
2687
2688 /* srli */
2689 void
2690 OP_3001 (SIM_DESC sd, SIM_CPU *cpu)
2691 {
2692 int64 tmp;
2693 if (OP[1] == 0)
2694 OP[1] = 16;
2695
2696 trace_input ("srli", OP_ACCUM, OP_CONSTANT16, OP_VOID);
2697 tmp = ((uint64)(ACC (OP[0]) & MASK40) >> OP[1]);
2698 SET_ACC (OP[0], tmp);
2699 trace_output_40 (sd, tmp);
2700 }
2701
2702 /* srx */
2703 void
2704 OP_4609 (SIM_DESC sd, SIM_CPU *cpu)
2705 {
2706 uint16 tmp;
2707 trace_input ("srx", OP_REG, OP_VOID, OP_VOID);
2708 tmp = PSW_F0 << 15;
2709 tmp = ((GPR (OP[0]) >> 1) | tmp);
2710 SET_GPR (OP[0], tmp);
2711 trace_output_16 (sd, tmp);
2712 }
2713
2714 /* st */
2715 void
2716 OP_34000000 (SIM_DESC sd, SIM_CPU *cpu)
2717 {
2718 uint16 addr = OP[1] + GPR (OP[2]);
2719 trace_input ("st", OP_REG, OP_MEMREF2, OP_VOID);
2720 if ((addr & 1))
2721 {
2722 trace_output_void (sd);
2723 EXCEPTION (SIM_SIGBUS);
2724 }
2725 SW (addr, GPR (OP[0]));
2726 trace_output_void (sd);
2727 }
2728
2729 /* st */
2730 void
2731 OP_6800 (SIM_DESC sd, SIM_CPU *cpu)
2732 {
2733 uint16 addr = GPR (OP[1]);
2734 trace_input ("st", OP_REG, OP_MEMREF, OP_VOID);
2735 if ((addr & 1))
2736 {
2737 trace_output_void (sd);
2738 EXCEPTION (SIM_SIGBUS);
2739 }
2740 SW (addr, GPR (OP[0]));
2741 trace_output_void (sd);
2742 }
2743
2744 /* st */
2745 /* st Rsrc1,@-SP */
2746 void
2747 OP_6C1F (SIM_DESC sd, SIM_CPU *cpu)
2748 {
2749 uint16 addr = GPR (OP[1]) - 2;
2750 trace_input ("st", OP_REG, OP_PREDEC, OP_VOID);
2751 if (OP[1] != 15)
2752 {
2753 sim_io_printf (sd, "ERROR: cannot pre-decrement any registers but r15 (SP).\n");
2754 EXCEPTION (SIM_SIGILL);
2755 }
2756 if ((addr & 1))
2757 {
2758 trace_output_void (sd);
2759 EXCEPTION (SIM_SIGBUS);
2760 }
2761 SW (addr, GPR (OP[0]));
2762 SET_GPR (OP[1], addr);
2763 trace_output_void (sd);
2764 }
2765
2766 /* st */
2767 void
2768 OP_6801 (SIM_DESC sd, SIM_CPU *cpu)
2769 {
2770 uint16 addr = GPR (OP[1]);
2771 trace_input ("st", OP_REG, OP_POSTINC, OP_VOID);
2772 if ((addr & 1))
2773 {
2774 trace_output_void (sd);
2775 EXCEPTION (SIM_SIGBUS);
2776 }
2777 SW (addr, GPR (OP[0]));
2778 INC_ADDR (OP[1], 2);
2779 trace_output_void (sd);
2780 }
2781
2782 /* st */
2783 void
2784 OP_6C01 (SIM_DESC sd, SIM_CPU *cpu)
2785 {
2786 uint16 addr = GPR (OP[1]);
2787 trace_input ("st", OP_REG, OP_POSTDEC, OP_VOID);
2788 if ( OP[1] == 15 )
2789 {
2790 sim_io_printf (sd, "ERROR: cannot post-decrement register r15 (SP).\n");
2791 EXCEPTION (SIM_SIGILL);
2792 }
2793 if ((addr & 1))
2794 {
2795 trace_output_void (sd);
2796 EXCEPTION (SIM_SIGBUS);
2797 }
2798 SW (addr, GPR (OP[0]));
2799 INC_ADDR (OP[1], -2);
2800 trace_output_void (sd);
2801 }
2802
2803 /* st */
2804 void
2805 OP_36010000 (SIM_DESC sd, SIM_CPU *cpu)
2806 {
2807 uint16 addr = OP[1];
2808 trace_input ("st", OP_REG, OP_MEMREF3, OP_VOID);
2809 if ((addr & 1))
2810 {
2811 trace_output_void (sd);
2812 EXCEPTION (SIM_SIGBUS);
2813 }
2814 SW (addr, GPR (OP[0]));
2815 trace_output_void (sd);
2816 }
2817
2818 /* st2w */
2819 void
2820 OP_35000000 (SIM_DESC sd, SIM_CPU *cpu)
2821 {
2822 uint16 addr = GPR (OP[2])+ OP[1];
2823 trace_input ("st2w", OP_DREG, OP_MEMREF2, OP_VOID);
2824 if ((addr & 1))
2825 {
2826 trace_output_void (sd);
2827 EXCEPTION (SIM_SIGBUS);
2828 }
2829 SW (addr + 0, GPR (OP[0] + 0));
2830 SW (addr + 2, GPR (OP[0] + 1));
2831 trace_output_void (sd);
2832 }
2833
2834 /* st2w */
2835 void
2836 OP_6A00 (SIM_DESC sd, SIM_CPU *cpu)
2837 {
2838 uint16 addr = GPR (OP[1]);
2839 trace_input ("st2w", OP_DREG, OP_MEMREF, OP_VOID);
2840 if ((addr & 1))
2841 {
2842 trace_output_void (sd);
2843 EXCEPTION (SIM_SIGBUS);
2844 }
2845 SW (addr + 0, GPR (OP[0] + 0));
2846 SW (addr + 2, GPR (OP[0] + 1));
2847 trace_output_void (sd);
2848 }
2849
2850 /* st2w */
2851 void
2852 OP_6E1F (SIM_DESC sd, SIM_CPU *cpu)
2853 {
2854 uint16 addr = GPR (OP[1]) - 4;
2855 trace_input ("st2w", OP_DREG, OP_PREDEC, OP_VOID);
2856 if ( OP[1] != 15 )
2857 {
2858 sim_io_printf (sd, "ERROR: cannot pre-decrement any registers but r15 (SP).\n");
2859 EXCEPTION (SIM_SIGILL);
2860 }
2861 if ((addr & 1))
2862 {
2863 trace_output_void (sd);
2864 EXCEPTION (SIM_SIGBUS);
2865 }
2866 SW (addr + 0, GPR (OP[0] + 0));
2867 SW (addr + 2, GPR (OP[0] + 1));
2868 SET_GPR (OP[1], addr);
2869 trace_output_void (sd);
2870 }
2871
2872 /* st2w */
2873 void
2874 OP_6A01 (SIM_DESC sd, SIM_CPU *cpu)
2875 {
2876 uint16 addr = GPR (OP[1]);
2877 trace_input ("st2w", OP_DREG, OP_POSTINC, OP_VOID);
2878 if ((addr & 1))
2879 {
2880 trace_output_void (sd);
2881 EXCEPTION (SIM_SIGBUS);
2882 }
2883 SW (addr + 0, GPR (OP[0] + 0));
2884 SW (addr + 2, GPR (OP[0] + 1));
2885 INC_ADDR (OP[1], 4);
2886 trace_output_void (sd);
2887 }
2888
2889 /* st2w */
2890 void
2891 OP_6E01 (SIM_DESC sd, SIM_CPU *cpu)
2892 {
2893 uint16 addr = GPR (OP[1]);
2894 trace_input ("st2w", OP_DREG, OP_POSTDEC, OP_VOID);
2895 if ( OP[1] == 15 )
2896 {
2897 sim_io_printf (sd, "ERROR: cannot post-decrement register r15 (SP).\n");
2898 EXCEPTION (SIM_SIGILL);
2899 }
2900 if ((addr & 1))
2901 {
2902 trace_output_void (sd);
2903 EXCEPTION (SIM_SIGBUS);
2904 }
2905 SW (addr + 0, GPR (OP[0] + 0));
2906 SW (addr + 2, GPR (OP[0] + 1));
2907 INC_ADDR (OP[1], -4);
2908 trace_output_void (sd);
2909 }
2910
2911 /* st2w */
2912 void
2913 OP_37010000 (SIM_DESC sd, SIM_CPU *cpu)
2914 {
2915 uint16 addr = OP[1];
2916 trace_input ("st2w", OP_DREG, OP_MEMREF3, OP_VOID);
2917 if ((addr & 1))
2918 {
2919 trace_output_void (sd);
2920 EXCEPTION (SIM_SIGBUS);
2921 }
2922 SW (addr + 0, GPR (OP[0] + 0));
2923 SW (addr + 2, GPR (OP[0] + 1));
2924 trace_output_void (sd);
2925 }
2926
2927 /* stb */
2928 void
2929 OP_3C000000 (SIM_DESC sd, SIM_CPU *cpu)
2930 {
2931 trace_input ("stb", OP_REG, OP_MEMREF2, OP_VOID);
2932 SB (GPR (OP[2]) + OP[1], GPR (OP[0]));
2933 trace_output_void (sd);
2934 }
2935
2936 /* stb */
2937 void
2938 OP_7800 (SIM_DESC sd, SIM_CPU *cpu)
2939 {
2940 trace_input ("stb", OP_REG, OP_MEMREF, OP_VOID);
2941 SB (GPR (OP[1]), GPR (OP[0]));
2942 trace_output_void (sd);
2943 }
2944
2945 /* stop */
2946 void
2947 OP_5FE0 (SIM_DESC sd, SIM_CPU *cpu)
2948 {
2949 trace_input ("stop", OP_VOID, OP_VOID, OP_VOID);
2950 trace_output_void (sd);
2951 sim_engine_halt (sd, cpu, NULL, PC, sim_exited, 0);
2952 }
2953
2954 /* sub */
2955 void
2956 OP_0 (SIM_DESC sd, SIM_CPU *cpu)
2957 {
2958 uint16 a = GPR (OP[0]);
2959 uint16 b = GPR (OP[1]);
2960 uint16 tmp = (a - b);
2961 trace_input ("sub", OP_REG, OP_REG, OP_VOID);
2962 /* see ../common/sim-alu.h for a more extensive discussion on how to
2963 compute the carry/overflow bits. */
2964 SET_PSW_C (a >= b);
2965 SET_GPR (OP[0], tmp);
2966 trace_output_16 (sd, tmp);
2967 }
2968
2969 /* sub */
2970 void
2971 OP_1001 (SIM_DESC sd, SIM_CPU *cpu)
2972 {
2973 int64 tmp;
2974
2975 trace_input ("sub", OP_ACCUM, OP_DREG, OP_VOID);
2976 tmp = SEXT40(ACC (OP[0])) - (SEXT16 (GPR (OP[1])) << 16 | GPR (OP[1] + 1));
2977 if (PSW_ST)
2978 {
2979 if (tmp > SEXT40(MAX32))
2980 tmp = (MAX32);
2981 else if (tmp < SEXT40(MIN32))
2982 tmp = (MIN32);
2983 else
2984 tmp = (tmp & MASK40);
2985 }
2986 else
2987 tmp = (tmp & MASK40);
2988 SET_ACC (OP[0], tmp);
2989
2990 trace_output_40 (sd, tmp);
2991 }
2992
2993 /* sub */
2994
2995 void
2996 OP_1003 (SIM_DESC sd, SIM_CPU *cpu)
2997 {
2998 int64 tmp;
2999
3000 trace_input ("sub", OP_ACCUM, OP_ACCUM, OP_VOID);
3001 tmp = SEXT40(ACC (OP[0])) - SEXT40(ACC (OP[1]));
3002 if (PSW_ST)
3003 {
3004 if (tmp > SEXT40(MAX32))
3005 tmp = (MAX32);
3006 else if (tmp < SEXT40(MIN32))
3007 tmp = (MIN32);
3008 else
3009 tmp = (tmp & MASK40);
3010 }
3011 else
3012 tmp = (tmp & MASK40);
3013 SET_ACC (OP[0], tmp);
3014
3015 trace_output_40 (sd, tmp);
3016 }
3017
3018 /* sub2w */
3019 void
3020 OP_1000 (SIM_DESC sd, SIM_CPU *cpu)
3021 {
3022 uint32 tmp, a, b;
3023
3024 trace_input ("sub2w", OP_DREG, OP_DREG, OP_VOID);
3025 a = (uint32)((GPR (OP[0]) << 16) | GPR (OP[0] + 1));
3026 b = (uint32)((GPR (OP[1]) << 16) | GPR (OP[1] + 1));
3027 /* see ../common/sim-alu.h for a more extensive discussion on how to
3028 compute the carry/overflow bits */
3029 tmp = a - b;
3030 SET_PSW_C (a >= b);
3031 SET_GPR32 (OP[0], tmp);
3032 trace_output_32 (sd, tmp);
3033 }
3034
3035 /* subac3 */
3036 void
3037 OP_17000000 (SIM_DESC sd, SIM_CPU *cpu)
3038 {
3039 int64 tmp;
3040
3041 trace_input ("subac3", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM);
3042 tmp = SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1)) - SEXT40 (ACC (OP[2]));
3043 SET_GPR32 (OP[0], tmp);
3044 trace_output_32 (sd, tmp);
3045 }
3046
3047 /* subac3 */
3048 void
3049 OP_17000002 (SIM_DESC sd, SIM_CPU *cpu)
3050 {
3051 int64 tmp;
3052
3053 trace_input ("subac3", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM);
3054 tmp = SEXT40 (ACC (OP[1])) - SEXT40(ACC (OP[2]));
3055 SET_GPR32 (OP[0], tmp);
3056 trace_output_32 (sd, tmp);
3057 }
3058
3059 /* subac3s */
3060 void
3061 OP_17001000 (SIM_DESC sd, SIM_CPU *cpu)
3062 {
3063 int64 tmp;
3064
3065 trace_input ("subac3s", OP_DREG_OUTPUT, OP_DREG, OP_ACCUM);
3066 SET_PSW_F1 (PSW_F0);
3067 tmp = SEXT40 ((GPR (OP[1]) << 16) | GPR (OP[1] + 1)) - SEXT40(ACC (OP[2]));
3068 if (tmp > SEXT40(MAX32))
3069 {
3070 tmp = (MAX32);
3071 SET_PSW_F0 (1);
3072 }
3073 else if (tmp < SEXT40(MIN32))
3074 {
3075 tmp = (MIN32);
3076 SET_PSW_F0 (1);
3077 }
3078 else
3079 {
3080 SET_PSW_F0 (0);
3081 }
3082 SET_GPR32 (OP[0], tmp);
3083 trace_output_32 (sd, tmp);
3084 }
3085
3086 /* subac3s */
3087 void
3088 OP_17001002 (SIM_DESC sd, SIM_CPU *cpu)
3089 {
3090 int64 tmp;
3091
3092 trace_input ("subac3s", OP_DREG_OUTPUT, OP_ACCUM, OP_ACCUM);
3093 SET_PSW_F1 (PSW_F0);
3094 tmp = SEXT40(ACC (OP[1])) - SEXT40(ACC (OP[2]));
3095 if (tmp > SEXT40(MAX32))
3096 {
3097 tmp = (MAX32);
3098 SET_PSW_F0 (1);
3099 }
3100 else if (tmp < SEXT40(MIN32))
3101 {
3102 tmp = (MIN32);
3103 SET_PSW_F0 (1);
3104 }
3105 else
3106 {
3107 SET_PSW_F0 (0);
3108 }
3109 SET_GPR32 (OP[0], tmp);
3110 trace_output_32 (sd, tmp);
3111 }
3112
3113 /* subi */
3114 void
3115 OP_1 (SIM_DESC sd, SIM_CPU *cpu)
3116 {
3117 unsigned tmp;
3118 if (OP[1] == 0)
3119 OP[1] = 16;
3120
3121 trace_input ("subi", OP_REG, OP_CONSTANT16, OP_VOID);
3122 /* see ../common/sim-alu.h for a more extensive discussion on how to
3123 compute the carry/overflow bits. */
3124 /* since OP[1] is never <= 0, -OP[1] == ~OP[1]+1 can never overflow */
3125 tmp = ((unsigned)(unsigned16) GPR (OP[0])
3126 + (unsigned)(unsigned16) ( - OP[1]));
3127 SET_PSW_C (tmp >= (1 << 16));
3128 SET_GPR (OP[0], tmp);
3129 trace_output_16 (sd, tmp);
3130 }
3131
3132 /* trap */
3133 void
3134 OP_5F00 (SIM_DESC sd, SIM_CPU *cpu)
3135 {
3136 host_callback *cb = STATE_CALLBACK (sd);
3137
3138 trace_input ("trap", OP_CONSTANT4, OP_VOID, OP_VOID);
3139 trace_output_void (sd);
3140
3141 switch (OP[0])
3142 {
3143 default:
3144 #if (DEBUG & DEBUG_TRAP) == 0
3145 {
3146 uint16 vec = OP[0] + TRAP_VECTOR_START;
3147 SET_BPC (PC + 1);
3148 SET_BPSW (PSW);
3149 SET_PSW (PSW & PSW_SM_BIT);
3150 JMP (vec);
3151 break;
3152 }
3153 #else /* if debugging use trap to print registers */
3154 {
3155 int i;
3156 static int first_time = 1;
3157
3158 if (first_time)
3159 {
3160 first_time = 0;
3161 sim_io_printf (sd, "Trap # PC ");
3162 for (i = 0; i < 16; i++)
3163 sim_io_printf (sd, " %sr%d", (i > 9) ? "" : " ", i);
3164 sim_io_printf (sd, " a0 a1 f0 f1 c\n");
3165 }
3166
3167 sim_io_printf (sd, "Trap %2d 0x%.4x:", (int)OP[0], (int)PC);
3168
3169 for (i = 0; i < 16; i++)
3170 sim_io_printf (sd, " %.4x", (int) GPR (i));
3171
3172 for (i = 0; i < 2; i++)
3173 sim_io_printf (sd, " %.2x%.8lx",
3174 ((int)(ACC (i) >> 32) & 0xff),
3175 ((unsigned long) ACC (i)) & 0xffffffff);
3176
3177 sim_io_printf (sd, " %d %d %d\n",
3178 PSW_F0 != 0, PSW_F1 != 0, PSW_C != 0);
3179 sim_io_flush_stdout (sd);
3180 break;
3181 }
3182 #endif
3183 case 15: /* new system call trap */
3184 /* Trap 15 is used for simulating low-level I/O */
3185 {
3186 unsigned32 result = 0;
3187 errno = 0;
3188
3189 /* Registers passed to trap 0 */
3190
3191 #define FUNC GPR (4) /* function number */
3192 #define PARM1 GPR (0) /* optional parm 1 */
3193 #define PARM2 GPR (1) /* optional parm 2 */
3194 #define PARM3 GPR (2) /* optional parm 3 */
3195 #define PARM4 GPR (3) /* optional parm 3 */
3196
3197 /* Registers set by trap 0 */
3198
3199 #define RETVAL(X) do { result = (X); SET_GPR (0, result); } while (0)
3200 #define RETVAL32(X) do { result = (X); SET_GPR (0, result >> 16); SET_GPR (1, result); } while (0)
3201 #define RETERR(X) SET_GPR (4, (X)) /* return error code */
3202
3203 /* Turn a pointer in a register into a pointer into real memory. */
3204
3205 #define MEMPTR(x) ((char *)(dmem_addr (sd, cpu, x)))
3206
3207 switch (FUNC)
3208 {
3209 #if !defined(__GO32__) && !defined(_WIN32)
3210 case TARGET_SYS_fork:
3211 trace_input ("<fork>", OP_VOID, OP_VOID, OP_VOID);
3212 RETVAL (fork ());
3213 trace_output_16 (sd, result);
3214 break;
3215
3216 #define getpid() 47
3217 case TARGET_SYS_getpid:
3218 trace_input ("<getpid>", OP_VOID, OP_VOID, OP_VOID);
3219 RETVAL (getpid ());
3220 trace_output_16 (sd, result);
3221 break;
3222
3223 case TARGET_SYS_kill:
3224 trace_input ("<kill>", OP_R0, OP_R1, OP_VOID);
3225 if (PARM1 == getpid ())
3226 {
3227 trace_output_void (sd);
3228 sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, PARM2);
3229 }
3230 else
3231 {
3232 int os_sig = -1;
3233 switch (PARM2)
3234 {
3235 #ifdef SIGHUP
3236 case 1: os_sig = SIGHUP; break;
3237 #endif
3238 #ifdef SIGINT
3239 case 2: os_sig = SIGINT; break;
3240 #endif
3241 #ifdef SIGQUIT
3242 case 3: os_sig = SIGQUIT; break;
3243 #endif
3244 #ifdef SIGILL
3245 case 4: os_sig = SIGILL; break;
3246 #endif
3247 #ifdef SIGTRAP
3248 case 5: os_sig = SIGTRAP; break;
3249 #endif
3250 #ifdef SIGABRT
3251 case 6: os_sig = SIGABRT; break;
3252 #elif defined(SIGIOT)
3253 case 6: os_sig = SIGIOT; break;
3254 #endif
3255 #ifdef SIGEMT
3256 case 7: os_sig = SIGEMT; break;
3257 #endif
3258 #ifdef SIGFPE
3259 case 8: os_sig = SIGFPE; break;
3260 #endif
3261 #ifdef SIGKILL
3262 case 9: os_sig = SIGKILL; break;
3263 #endif
3264 #ifdef SIGBUS
3265 case 10: os_sig = SIGBUS; break;
3266 #endif
3267 #ifdef SIGSEGV
3268 case 11: os_sig = SIGSEGV; break;
3269 #endif
3270 #ifdef SIGSYS
3271 case 12: os_sig = SIGSYS; break;
3272 #endif
3273 #ifdef SIGPIPE
3274 case 13: os_sig = SIGPIPE; break;
3275 #endif
3276 #ifdef SIGALRM
3277 case 14: os_sig = SIGALRM; break;
3278 #endif
3279 #ifdef SIGTERM
3280 case 15: os_sig = SIGTERM; break;
3281 #endif
3282 #ifdef SIGURG
3283 case 16: os_sig = SIGURG; break;
3284 #endif
3285 #ifdef SIGSTOP
3286 case 17: os_sig = SIGSTOP; break;
3287 #endif
3288 #ifdef SIGTSTP
3289 case 18: os_sig = SIGTSTP; break;
3290 #endif
3291 #ifdef SIGCONT
3292 case 19: os_sig = SIGCONT; break;
3293 #endif
3294 #ifdef SIGCHLD
3295 case 20: os_sig = SIGCHLD; break;
3296 #elif defined(SIGCLD)
3297 case 20: os_sig = SIGCLD; break;
3298 #endif
3299 #ifdef SIGTTIN
3300 case 21: os_sig = SIGTTIN; break;
3301 #endif
3302 #ifdef SIGTTOU
3303 case 22: os_sig = SIGTTOU; break;
3304 #endif
3305 #ifdef SIGIO
3306 case 23: os_sig = SIGIO; break;
3307 #elif defined (SIGPOLL)
3308 case 23: os_sig = SIGPOLL; break;
3309 #endif
3310 #ifdef SIGXCPU
3311 case 24: os_sig = SIGXCPU; break;
3312 #endif
3313 #ifdef SIGXFSZ
3314 case 25: os_sig = SIGXFSZ; break;
3315 #endif
3316 #ifdef SIGVTALRM
3317 case 26: os_sig = SIGVTALRM; break;
3318 #endif
3319 #ifdef SIGPROF
3320 case 27: os_sig = SIGPROF; break;
3321 #endif
3322 #ifdef SIGWINCH
3323 case 28: os_sig = SIGWINCH; break;
3324 #endif
3325 #ifdef SIGLOST
3326 case 29: os_sig = SIGLOST; break;
3327 #endif
3328 #ifdef SIGUSR1
3329 case 30: os_sig = SIGUSR1; break;
3330 #endif
3331 #ifdef SIGUSR2
3332 case 31: os_sig = SIGUSR2; break;
3333 #endif
3334 }
3335
3336 if (os_sig == -1)
3337 {
3338 trace_output_void (sd);
3339 sim_io_printf (sd, "Unknown signal %d\n", PARM2);
3340 sim_io_flush_stdout (sd);
3341 EXCEPTION (SIM_SIGILL);
3342 }
3343 else
3344 {
3345 RETVAL (kill (PARM1, PARM2));
3346 trace_output_16 (sd, result);
3347 }
3348 }
3349 break;
3350
3351 case TARGET_SYS_execve:
3352 trace_input ("<execve>", OP_R0, OP_R1, OP_R2);
3353 RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2),
3354 (char **)MEMPTR (PARM3)));
3355 trace_output_16 (sd, result);
3356 break;
3357
3358 #ifdef TARGET_SYS_execv
3359 case TARGET_SYS_execv:
3360 trace_input ("<execv>", OP_R0, OP_R1, OP_VOID);
3361 RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL));
3362 trace_output_16 (sd, result);
3363 break;
3364 #endif
3365
3366 case TARGET_SYS_pipe:
3367 {
3368 reg_t buf;
3369 int host_fd[2];
3370
3371 trace_input ("<pipe>", OP_R0, OP_VOID, OP_VOID);
3372 buf = PARM1;
3373 RETVAL (pipe (host_fd));
3374 SW (buf, host_fd[0]);
3375 buf += sizeof(uint16);
3376 SW (buf, host_fd[1]);
3377 trace_output_16 (sd, result);
3378 }
3379 break;
3380
3381 #if 0
3382 #ifdef TARGET_SYS_wait
3383 case TARGET_SYS_wait:
3384 {
3385 int status;
3386 trace_input ("<wait>", OP_R0, OP_VOID, OP_VOID);
3387 RETVAL (wait (&status));
3388 if (PARM1)
3389 SW (PARM1, status);
3390 trace_output_16 (sd, result);
3391 }
3392 break;
3393 #endif
3394 #endif
3395 #else
3396 case TARGET_SYS_getpid:
3397 trace_input ("<getpid>", OP_VOID, OP_VOID, OP_VOID);
3398 RETVAL (1);
3399 trace_output_16 (sd, result);
3400 break;
3401
3402 case TARGET_SYS_kill:
3403 trace_input ("<kill>", OP_REG, OP_REG, OP_VOID);
3404 trace_output_void (sd);
3405 sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, PARM2);
3406 break;
3407 #endif
3408
3409 case TARGET_SYS_read:
3410 trace_input ("<read>", OP_R0, OP_R1, OP_R2);
3411 RETVAL (cb->read (cb, PARM1, MEMPTR (PARM2), PARM3));
3412 trace_output_16 (sd, result);
3413 break;
3414
3415 case TARGET_SYS_write:
3416 trace_input ("<write>", OP_R0, OP_R1, OP_R2);
3417 if (PARM1 == 1)
3418 RETVAL ((int)cb->write_stdout (cb, MEMPTR (PARM2), PARM3));
3419 else
3420 RETVAL ((int)cb->write (cb, PARM1, MEMPTR (PARM2), PARM3));
3421 trace_output_16 (sd, result);
3422 break;
3423
3424 case TARGET_SYS_lseek:
3425 trace_input ("<lseek>", OP_R0, OP_R1, OP_R2);
3426 RETVAL32 (cb->lseek (cb, PARM1,
3427 ((((unsigned long) PARM2) << 16)
3428 || (unsigned long) PARM3),
3429 PARM4));
3430 trace_output_32 (sd, result);
3431 break;
3432
3433 case TARGET_SYS_close:
3434 trace_input ("<close>", OP_R0, OP_VOID, OP_VOID);
3435 RETVAL (cb->close (cb, PARM1));
3436 trace_output_16 (sd, result);
3437 break;
3438
3439 case TARGET_SYS_open:
3440 trace_input ("<open>", OP_R0, OP_R1, OP_R2);
3441 RETVAL (cb->open (cb, MEMPTR (PARM1), PARM2));
3442 trace_output_16 (sd, result);
3443 break;
3444
3445 case TARGET_SYS_exit:
3446 trace_input ("<exit>", OP_R0, OP_VOID, OP_VOID);
3447 trace_output_void (sd);
3448 sim_engine_halt (sd, cpu, NULL, PC, sim_exited, GPR (0));
3449 break;
3450
3451 #ifdef TARGET_SYS_stat
3452 case TARGET_SYS_stat:
3453 trace_input ("<stat>", OP_R0, OP_R1, OP_VOID);
3454 /* stat system call */
3455 {
3456 struct stat host_stat;
3457 reg_t buf;
3458
3459 RETVAL (stat (MEMPTR (PARM1), &host_stat));
3460
3461 buf = PARM2;
3462
3463 /* The hard-coded offsets and sizes were determined by using
3464 * the D10V compiler on a test program that used struct stat.
3465 */
3466 SW (buf, host_stat.st_dev);
3467 SW (buf+2, host_stat.st_ino);
3468 SW (buf+4, host_stat.st_mode);
3469 SW (buf+6, host_stat.st_nlink);
3470 SW (buf+8, host_stat.st_uid);
3471 SW (buf+10, host_stat.st_gid);
3472 SW (buf+12, host_stat.st_rdev);
3473 SLW (buf+16, host_stat.st_size);
3474 SLW (buf+20, host_stat.st_atime);
3475 SLW (buf+28, host_stat.st_mtime);
3476 SLW (buf+36, host_stat.st_ctime);
3477 }
3478 trace_output_16 (sd, result);
3479 break;
3480 #endif
3481
3482 case TARGET_SYS_chown:
3483 trace_input ("<chown>", OP_R0, OP_R1, OP_R2);
3484 RETVAL (chown (MEMPTR (PARM1), PARM2, PARM3));
3485 trace_output_16 (sd, result);
3486 break;
3487
3488 case TARGET_SYS_chmod:
3489 trace_input ("<chmod>", OP_R0, OP_R1, OP_R2);
3490 RETVAL (chmod (MEMPTR (PARM1), PARM2));
3491 trace_output_16 (sd, result);
3492 break;
3493
3494 #if 0
3495 #ifdef TARGET_SYS_utime
3496 case TARGET_SYS_utime:
3497 trace_input ("<utime>", OP_R0, OP_R1, OP_R2);
3498 /* Cast the second argument to void *, to avoid type mismatch
3499 if a prototype is present. */
3500 RETVAL (utime (MEMPTR (PARM1), (void *) MEMPTR (PARM2)));
3501 trace_output_16 (sd, result);
3502 break;
3503 #endif
3504 #endif
3505
3506 #if 0
3507 #ifdef TARGET_SYS_time
3508 case TARGET_SYS_time:
3509 trace_input ("<time>", OP_R0, OP_R1, OP_R2);
3510 RETVAL32 (time (PARM1 ? MEMPTR (PARM1) : NULL));
3511 trace_output_32 (sd, result);
3512 break;
3513 #endif
3514 #endif
3515
3516 default:
3517 cb->error (cb, "Unknown syscall %d", FUNC);
3518 }
3519 if ((uint16) result == (uint16) -1)
3520 RETERR (cb->get_errno (cb));
3521 else
3522 RETERR (0);
3523 break;
3524 }
3525 }
3526 }
3527
3528 /* tst0i */
3529 void
3530 OP_7000000 (SIM_DESC sd, SIM_CPU *cpu)
3531 {
3532 trace_input ("tst0i", OP_REG, OP_CONSTANT16, OP_VOID);
3533 SET_PSW_F1 (PSW_F0);;
3534 SET_PSW_F0 ((GPR (OP[0]) & OP[1]) ? 1 : 0);
3535 trace_output_flag (sd);
3536 }
3537
3538 /* tst1i */
3539 void
3540 OP_F000000 (SIM_DESC sd, SIM_CPU *cpu)
3541 {
3542 trace_input ("tst1i", OP_REG, OP_CONSTANT16, OP_VOID);
3543 SET_PSW_F1 (PSW_F0);
3544 SET_PSW_F0 ((~(GPR (OP[0])) & OP[1]) ? 1 : 0);
3545 trace_output_flag (sd);
3546 }
3547
3548 /* wait */
3549 void
3550 OP_5F80 (SIM_DESC sd, SIM_CPU *cpu)
3551 {
3552 trace_input ("wait", OP_VOID, OP_VOID, OP_VOID);
3553 SET_PSW_IE (1);
3554 trace_output_void (sd);
3555 }
3556
3557 /* xor */
3558 void
3559 OP_A00 (SIM_DESC sd, SIM_CPU *cpu)
3560 {
3561 int16 tmp;
3562 trace_input ("xor", OP_REG, OP_REG, OP_VOID);
3563 tmp = (GPR (OP[0]) ^ GPR (OP[1]));
3564 SET_GPR (OP[0], tmp);
3565 trace_output_16 (sd, tmp);
3566 }
3567
3568 /* xor3 */
3569 void
3570 OP_5000000 (SIM_DESC sd, SIM_CPU *cpu)
3571 {
3572 int16 tmp;
3573 trace_input ("xor3", OP_REG_OUTPUT, OP_REG, OP_CONSTANT16);
3574 tmp = (GPR (OP[1]) ^ OP[2]);
3575 SET_GPR (OP[0], tmp);
3576 trace_output_16 (sd, tmp);
3577 }
The GNU Binutils are a collection of binary tools.