?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[src/erc32] Use ncurses instead of termcap on Cygwin too
[binutils-gdb.git] / sim / cr16 / simops.c
blob8a57a67a32921b83e89e0652c299f7238d3a31b2
1 /* Simulation code for the CR16 processor.
2 Copyright (C) 2008-2018 Free Software Foundation, Inc.
3 Contributed by M Ranga Swami Reddy <MR.Swami.Reddy@nsc.com>
4
5 This file is part of GDB, the GNU debugger.
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
10 any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program. If not, see <http://www.gnu.org/licenses/>. */
19
20
21 #include "config.h"
22
23 #include <signal.h>
24 #include <errno.h>
25 #include <sys/types.h>
26 #include <sys/stat.h>
27 #ifdef HAVE_UNISTD_H
28 #include <unistd.h>
29 #endif
30 #ifdef HAVE_STRING_H
31 #include <string.h>
32 #endif
33 #ifdef HAVE_TIME_H
34 #include <time.h>
35 #endif
36 #ifdef HAVE_SYS_TIME_H
37 #include <sys/time.h>
38 #endif
39
40 #include "sim-main.h"
41 #include "simops.h"
42 #include "targ-vals.h"
43
44 #ifdef TARGET_SYS_utime
45 #include <utime.h>
46 #endif
47 #ifdef TARGET_SYS_wait
48 #include <sys/wait.h>
49 #endif
50
51 #define EXCEPTION(sig) sim_engine_halt (sd, cpu, NULL, PC, sim_stopped, sig)
52
53 enum op_types {
54 OP_VOID,
55 OP_CONSTANT3,
56 OP_UCONSTANT3,
57 OP_CONSTANT4,
58 OP_CONSTANT4_1,
59 OP_CONSTANT5,
60 OP_CONSTANT6,
61 OP_CONSTANT16,
62 OP_UCONSTANT16,
63 OP_CONSTANT20,
64 OP_UCONSTANT20,
65 OP_CONSTANT32,
66 OP_UCONSTANT32,
67 OP_MEMREF,
68 OP_MEMREF2,
69 OP_MEMREF3,
70
71 OP_DISP5,
72 OP_DISP17,
73 OP_DISP25,
74 OP_DISPE9,
75 //OP_ABS20,
76 OP_ABS20_OUTPUT,
77 //OP_ABS24,
78 OP_ABS24_OUTPUT,
79
80 OP_R_BASE_DISPS16,
81 OP_R_BASE_DISP20,
82 OP_R_BASE_DISPS20,
83 OP_R_BASE_DISPE20,
84
85 OP_RP_BASE_DISPE0,
86 OP_RP_BASE_DISP4,
87 OP_RP_BASE_DISPE4,
88 OP_RP_BASE_DISP14,
89 OP_RP_BASE_DISP16,
90 OP_RP_BASE_DISP20,
91 OP_RP_BASE_DISPS20,
92 OP_RP_BASE_DISPE20,
93
94 OP_R_INDEX7_ABS20,
95 OP_R_INDEX8_ABS20,
96
97 OP_RP_INDEX_DISP0,
98 OP_RP_INDEX_DISP14,
99 OP_RP_INDEX_DISP20,
100 OP_RP_INDEX_DISPS20,
101
102 OP_REG,
103 OP_REGP,
104 OP_PROC_REG,
105 OP_PROC_REGP,
106 OP_COND,
107 OP_RA
108 };
109
110
111 enum {
112 PSR_MASK = (PSR_I_BIT
113 | PSR_P_BIT
114 | PSR_E_BIT
115 | PSR_N_BIT
116 | PSR_Z_BIT
117 | PSR_F_BIT
118 | PSR_U_BIT
119 | PSR_L_BIT
120 | PSR_T_BIT
121 | PSR_C_BIT),
122 /* The following bits in the PSR _can't_ be set by instructions such
123 as mvtc. */
124 PSR_HW_MASK = (PSR_MASK)
125 };
126
127 /* cond Code Condition True State
128 * EQ Equal Z flag is 1
129 * NE Not Equal Z flag is 0
130 * CS Carry Set C flag is 1
131 * CC Carry Clear C flag is 0
132 * HI Higher L flag is 1
133 * LS Lower or Same L flag is 0
134 * GT Greater Than N flag is 1
135 * LE Less Than or Equal To N flag is 0
136 * FS Flag Set F flag is 1
137 * FC Flag Clear F flag is 0
138 * LO Lower Z and L flags are 0
139 * HS Higher or Same Z or L flag is 1
140 * LT Less Than Z and N flags are 0
141 * GE Greater Than or Equal To Z or N flag is 1. */
142
143 static int cond_stat(int cc)
144 {
145 switch (cc)
146 {
147 case 0: return PSR_Z; break;
148 case 1: return !PSR_Z; break;
149 case 2: return PSR_C; break;
150 case 3: return !PSR_C; break;
151 case 4: return PSR_L; break;
152 case 5: return !PSR_L; break;
153 case 6: return PSR_N; break;
154 case 7: return !PSR_N; break;
155 case 8: return PSR_F; break;
156 case 9: return !PSR_F; break;
157 case 10: return !PSR_Z && !PSR_L; break;
158 case 11: return PSR_Z || PSR_L; break;
159 case 12: return !PSR_Z && !PSR_N; break;
160 case 13: return PSR_Z || PSR_N; break;
161 case 14: return 1; break; /*ALWAYS. */
162 default:
163 // case NEVER: return false; break;
164 //case NO_COND_CODE:
165 //panic("Shouldn't have NO_COND_CODE in an actual instruction!");
166 return 0; break;
167 }
168 return 0;
169 }
170
171
172 creg_t
173 move_to_cr (SIM_DESC sd, SIM_CPU *cpu, int cr, creg_t mask, creg_t val, int psw_hw_p)
174 {
175 /* A MASK bit is set when the corresponding bit in the CR should
176 be left alone. */
177 /* This assumes that (VAL & MASK) == 0. */
178 switch (cr)
179 {
180 case PSR_CR:
181 if (psw_hw_p)
182 val &= PSR_HW_MASK;
183 #if 0
184 else
185 val &= PSR_MASK;
186 sim_io_printf
187 (sd,
188 "ERROR at PC 0x%x: ST can only be set when FX is set.\n", PC);
189 EXCEPTION (SIM_SIGILL);
190 #endif
191 /* keep an up-to-date psw around for tracing. */
192 State.trace.psw = (State.trace.psw & mask) | val;
193 break;
194 default:
195 break;
196 }
197 /* only issue an update if the register is being changed. */
198 if ((State.cregs[cr] & ~mask) != val)
199 SLOT_PEND_MASK (State.cregs[cr], mask, val);
200
201 return val;
202 }
203
204 #ifdef DEBUG
205 static void trace_input_func (SIM_DESC sd,
206 const char *name,
207 enum op_types in1,
208 enum op_types in2,
209 enum op_types in3);
210
211 #define trace_input(name, in1, in2, in3) do { if (cr16_debug) trace_input_func (sd, name, in1, in2, in3); } while (0)
212
213 #ifndef SIZE_INSTRUCTION
214 #define SIZE_INSTRUCTION 8
215 #endif
216
217 #ifndef SIZE_OPERANDS
218 #define SIZE_OPERANDS 18
219 #endif
220
221 #ifndef SIZE_VALUES
222 #define SIZE_VALUES 13
223 #endif
224
225 #ifndef SIZE_LOCATION
226 #define SIZE_LOCATION 20
227 #endif
228
229 #ifndef SIZE_PC
230 #define SIZE_PC 4
231 #endif
232
233 #ifndef SIZE_LINE_NUMBER
234 #define SIZE_LINE_NUMBER 2
235 #endif
236
237 static void
238 trace_input_func (SIM_DESC sd, const char *name, enum op_types in1, enum op_types in2, enum op_types in3)
239 {
240 char *comma;
241 enum op_types in[3];
242 int i;
243 char buf[1024];
244 char *p;
245 long tmp;
246 char *type;
247 const char *filename;
248 const char *functionname;
249 unsigned int linenumber;
250 bfd_vma byte_pc;
251
252 if ((cr16_debug & DEBUG_TRACE) == 0)
253 return;
254
255 switch (State.ins_type)
256 {
257 default:
258 case INS_UNKNOWN: type = " ?"; break;
259 }
260
261 if ((cr16_debug & DEBUG_LINE_NUMBER) == 0)
262 sim_io_printf (sd,
263 "0x%.*x %s: %-*s ",
264 SIZE_PC, (unsigned)PC,
265 type,
266 SIZE_INSTRUCTION, name);
267
268 else
269 {
270 buf[0] = '\0';
271 byte_pc = PC;
272 if (STATE_TEXT_SECTION (sd)
273 && byte_pc >= STATE_TEXT_START (sd)
274 && byte_pc < STATE_TEXT_END (sd))
275 {
276 filename = (const char *)0;
277 functionname = (const char *)0;
278 linenumber = 0;
279 if (bfd_find_nearest_line (STATE_PROG_BFD (sd),
280 STATE_TEXT_SECTION (sd),
281 (struct bfd_symbol **)0,
282 byte_pc - STATE_TEXT_START (sd),
283 &filename, &functionname, &linenumber))
284 {
285 p = buf;
286 if (linenumber)
287 {
288 sprintf (p, "#%-*d ", SIZE_LINE_NUMBER, linenumber);
289 p += strlen (p);
290 }
291 else
292 {
293 sprintf (p, "%-*s ", SIZE_LINE_NUMBER+1, "---");
294 p += SIZE_LINE_NUMBER+2;
295 }
296
297 if (functionname)
298 {
299 sprintf (p, "%s ", functionname);
300 p += strlen (p);
301 }
302 else if (filename)
303 {
304 char *q = strrchr (filename, '/');
305 sprintf (p, "%s ", (q) ? q+1 : filename);
306 p += strlen (p);
307 }
308
309 if (*p == ' ')
310 *p = '\0';
311 }
312 }
313
314 sim_io_printf (sd,
315 "0x%.*x %s: %-*.*s %-*s ",
316 SIZE_PC, (unsigned)PC,
317 type,
318 SIZE_LOCATION, SIZE_LOCATION, buf,
319 SIZE_INSTRUCTION, name);
320 }
321
322 in[0] = in1;
323 in[1] = in2;
324 in[2] = in3;
325 comma = "";
326 p = buf;
327 for (i = 0; i < 3; i++)
328 {
329 switch (in[i])
330 {
331 case OP_VOID:
332 break;
333
334 case OP_REG:
335 case OP_REGP:
336 sprintf (p, "%sr%d", comma, OP[i]);
337 p += strlen (p);
338 comma = ",";
339 break;
340
341 case OP_PROC_REG:
342 sprintf (p, "%scr%d", comma, OP[i]);
343 p += strlen (p);
344 comma = ",";
345 break;
346
347 case OP_CONSTANT16:
348 sprintf (p, "%s%d", comma, OP[i]);
349 p += strlen (p);
350 comma = ",";
351 break;
352
353 case OP_CONSTANT4:
354 sprintf (p, "%s%d", comma, SEXT4(OP[i]));
355 p += strlen (p);
356 comma = ",";
357 break;
358
359 case OP_CONSTANT3:
360 sprintf (p, "%s%d", comma, SEXT3(OP[i]));
361 p += strlen (p);
362 comma = ",";
363 break;
364
365 case OP_MEMREF:
366 sprintf (p, "%s@r%d", comma, OP[i]);
367 p += strlen (p);
368 comma = ",";
369 break;
370
371 case OP_MEMREF2:
372 sprintf (p, "%s@(%d,r%d)", comma, (int16)OP[i], OP[i+1]);
373 p += strlen (p);
374 comma = ",";
375 break;
376
377 case OP_MEMREF3:
378 sprintf (p, "%s@%d", comma, OP[i]);
379 p += strlen (p);
380 comma = ",";
381 break;
382 }
383 }
384
385 if ((cr16_debug & DEBUG_VALUES) == 0)
386 {
387 *p++ = '\n';
388 *p = '\0';
389 sim_io_printf (sd, "%s", buf);
390 }
391 else
392 {
393 *p = '\0';
394 sim_io_printf (sd, "%-*s", SIZE_OPERANDS, buf);
395
396 p = buf;
397 for (i = 0; i < 3; i++)
398 {
399 buf[0] = '\0';
400 switch (in[i])
401 {
402 case OP_VOID:
403 sim_io_printf (sd, "%*s", SIZE_VALUES, "");
404 break;
405
406 case OP_REG:
407 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
408 (uint16) GPR (OP[i]));
409 break;
410
411 case OP_REGP:
412 tmp = (long)((((uint32) GPR (OP[i])) << 16) | ((uint32) GPR (OP[i] + 1)));
413 sim_io_printf (sd, "%*s0x%.8lx", SIZE_VALUES-10, "", tmp);
414 break;
415
416 case OP_PROC_REG:
417 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
418 (uint16) CREG (OP[i]));
419 break;
420
421 case OP_CONSTANT16:
422 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
423 (uint16)OP[i]);
424 break;
425
426 case OP_CONSTANT4:
427 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
428 (uint16)SEXT4(OP[i]));
429 break;
430
431 case OP_CONSTANT3:
432 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
433 (uint16)SEXT3(OP[i]));
434 break;
435
436 case OP_MEMREF2:
437 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
438 (uint16)OP[i]);
439 sim_io_printf (sd, "%*s0x%.4x", SIZE_VALUES-6, "",
440 (uint16)GPR (OP[i + 1]));
441 i++;
442 break;
443 }
444 }
445 }
446
447 sim_io_flush_stdout (sd);
448 }
449
450 static void
451 do_trace_output_flush (SIM_DESC sd)
452 {
453 sim_io_flush_stdout (sd);
454 }
455
456 static void
457 do_trace_output_finish (SIM_DESC sd)
458 {
459 sim_io_printf (sd,
460 " F0=%d F1=%d C=%d\n",
461 (State.trace.psw & PSR_F_BIT) != 0,
462 (State.trace.psw & PSR_F_BIT) != 0,
463 (State.trace.psw & PSR_C_BIT) != 0);
464 sim_io_flush_stdout (sd);
465 }
466
467 #if 0
468 static void
469 trace_output_40 (SIM_DESC sd, uint64 val)
470 {
471 if ((cr16_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
472 {
473 sim_io_printf (sd,
474 " :: %*s0x%.2x%.8lx",
475 SIZE_VALUES - 12,
476 "",
477 ((int)(val >> 32) & 0xff),
478 ((unsigned long) val) & 0xffffffff);
479 do_trace_output_finish ();
480 }
481 }
482 #endif
483
484 static void
485 trace_output_32 (SIM_DESC sd, uint32 val)
486 {
487 if ((cr16_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
488 {
489 sim_io_printf (sd,
490 " :: %*s0x%.8x",
491 SIZE_VALUES - 10,
492 "",
493 (int) val);
494 do_trace_output_finish (sd);
495 }
496 }
497
498 static void
499 trace_output_16 (SIM_DESC sd, uint16 val)
500 {
501 if ((cr16_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
502 {
503 sim_io_printf (sd,
504 " :: %*s0x%.4x",
505 SIZE_VALUES - 6,
506 "",
507 (int) val);
508 do_trace_output_finish (sd);
509 }
510 }
511
512 static void
513 trace_output_void (SIM_DESC sd)
514 {
515 if ((cr16_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
516 {
517 sim_io_printf (sd, "\n");
518 do_trace_output_flush (sd);
519 }
520 }
521
522 static void
523 trace_output_flag (SIM_DESC sd)
524 {
525 if ((cr16_debug & (DEBUG_TRACE | DEBUG_VALUES)) == (DEBUG_TRACE | DEBUG_VALUES))
526 {
527 sim_io_printf (sd,
528 " :: %*s",
529 SIZE_VALUES,
530 "");
531 do_trace_output_finish (sd);
532 }
533 }
534
535
536
537
538 #else
539 #define trace_input(NAME, IN1, IN2, IN3)
540 #define trace_output(RESULT)
541 #endif
542
543 /* addub. */
544 void
545 OP_2C_8 (SIM_DESC sd, SIM_CPU *cpu)
546 {
547 uint8 tmp;
548 uint8 a = OP[0] & 0xff;
549 uint16 b = (GPR (OP[1])) & 0xff;
550 trace_input ("addub", OP_CONSTANT4_1, OP_REG, OP_VOID);
551 tmp = (a + b) & 0xff;
552 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
553 trace_output_16 (sd, tmp);
554 }
555
556 /* addub. */
557 void
558 OP_2CB_C (SIM_DESC sd, SIM_CPU *cpu)
559 {
560 uint16 tmp;
561 uint8 a = ((OP[0]) & 0xff), b = (GPR (OP[1])) & 0xff;
562 trace_input ("addub", OP_CONSTANT16, OP_REG, OP_VOID);
563 tmp = (a + b) & 0xff;
564 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
565 trace_output_16 (sd, tmp);
566 }
567
568 /* addub. */
569 void
570 OP_2D_8 (SIM_DESC sd, SIM_CPU *cpu)
571 {
572 uint8 a = (GPR (OP[0])) & 0xff;
573 uint8 b = (GPR (OP[1])) & 0xff;
574 uint16 tmp = (a + b) & 0xff;
575 trace_input ("addub", OP_REG, OP_REG, OP_VOID);
576 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
577 trace_output_16 (sd, tmp);
578 }
579
580 /* adduw. */
581 void
582 OP_2E_8 (SIM_DESC sd, SIM_CPU *cpu)
583 {
584 uint16 a = OP[0];
585 uint16 b = GPR (OP[1]);
586 uint16 tmp = (a + b);
587 trace_input ("adduw", OP_CONSTANT4_1, OP_REG, OP_VOID);
588 SET_GPR (OP[1], tmp);
589 trace_output_16 (sd, tmp);
590 }
591
592 /* adduw. */
593 void
594 OP_2EB_C (SIM_DESC sd, SIM_CPU *cpu)
595 {
596 uint16 a = OP[0];
597 uint16 b = GPR (OP[1]);
598 uint16 tmp = (a + b);
599 trace_input ("adduw", OP_CONSTANT16, OP_REG, OP_VOID);
600 SET_GPR (OP[1], tmp);
601 trace_output_16 (sd, tmp);
602 }
603
604 /* adduw. */
605 void
606 OP_2F_8 (SIM_DESC sd, SIM_CPU *cpu)
607 {
608 uint16 a = GPR (OP[0]);
609 uint16 b = GPR (OP[1]);
610 uint16 tmp = (a + b);
611 trace_input ("adduw", OP_REG, OP_REG, OP_VOID);
612 SET_GPR (OP[1], tmp);
613 trace_output_16 (sd, tmp);
614 }
615
616 /* addb. */
617 void
618 OP_30_8 (SIM_DESC sd, SIM_CPU *cpu)
619 {
620 uint8 a = OP[0];
621 uint8 b = (GPR (OP[1]) & 0xff);
622 uint16 tmp = (a + b) & 0xff;
623 trace_input ("addb", OP_CONSTANT4_1, OP_REG, OP_VOID);
624 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
625 SET_PSR_C (tmp > 0xFF);
626 SET_PSR_F (((a & 0x80) == (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
627 trace_output_16 (sd, tmp);
628 }
629
630 /* addb. */
631 void
632 OP_30B_C (SIM_DESC sd, SIM_CPU *cpu)
633 {
634 uint8 a = (OP[0]) & 0xff;
635 uint8 b = (GPR (OP[1]) & 0xff);
636 uint16 tmp = (a + b) & 0xff;
637 trace_input ("addb", OP_CONSTANT16, OP_REG, OP_VOID);
638 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
639 SET_PSR_C (tmp > 0xFF);
640 SET_PSR_F (((a & 0x80) == (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
641 trace_output_16 (sd, tmp);
642 }
643
644 /* addb. */
645 void
646 OP_31_8 (SIM_DESC sd, SIM_CPU *cpu)
647 {
648 uint8 a = (GPR (OP[0]) & 0xff);
649 uint8 b = (GPR (OP[1]) & 0xff);
650 uint16 tmp = (a + b) & 0xff;
651 trace_input ("addb", OP_REG, OP_REG, OP_VOID);
652 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
653 SET_PSR_C (tmp > 0xFF);
654 SET_PSR_F (((a & 0x80) == (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
655 trace_output_16 (sd, tmp);
656 }
657
658 /* addw. */
659 void
660 OP_32_8 (SIM_DESC sd, SIM_CPU *cpu)
661 {
662 int16 a = OP[0];
663 uint16 tmp, b = GPR (OP[1]);
664 tmp = (a + b);
665 trace_input ("addw", OP_CONSTANT4_1, OP_REG, OP_VOID);
666 SET_GPR (OP[1], tmp);
667 SET_PSR_C (tmp > 0xFFFF);
668 SET_PSR_F (((a & 0x8000) == (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
669 trace_output_16 (sd, tmp);
670 }
671
672 /* addw. */
673 void
674 OP_32B_C (SIM_DESC sd, SIM_CPU *cpu)
675 {
676 int16 a = OP[0];
677 uint16 tmp, b = GPR (OP[1]);
678 tmp = (a + b);
679 trace_input ("addw", OP_CONSTANT16, OP_REG, OP_VOID);
680 SET_GPR (OP[1], tmp);
681 SET_PSR_C (tmp > 0xFFFF);
682 SET_PSR_F (((a & 0x8000) == (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
683 trace_output_16 (sd, tmp);
684 }
685
686 /* addw. */
687 void
688 OP_33_8 (SIM_DESC sd, SIM_CPU *cpu)
689 {
690 uint16 tmp, a = (GPR (OP[0])), b = (GPR (OP[1]));
691 trace_input ("addw", OP_REG, OP_REG, OP_VOID);
692 tmp = (a + b);
693 SET_GPR (OP[1], tmp);
694 SET_PSR_C (tmp > 0xFFFF);
695 SET_PSR_F (((a & 0x8000) == (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
696 trace_output_16 (sd, tmp);
697 }
698
699 /* addcb. */
700 void
701 OP_34_8 (SIM_DESC sd, SIM_CPU *cpu)
702 {
703 uint8 tmp, a = OP[0] & 0xff, b = (GPR (OP[1])) & 0xff;
704 trace_input ("addcb", OP_CONSTANT4_1, OP_REG, OP_REG);
705 tmp = (a + b + PSR_C) & 0xff;
706 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
707 SET_PSR_C (tmp > 0xFF);
708 SET_PSR_F (((a & 0x80) == (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
709 trace_output_16 (sd, tmp);
710 }
711
712 /* addcb. */
713 void
714 OP_34B_C (SIM_DESC sd, SIM_CPU *cpu)
715 {
716 int8 a = OP[0] & 0xff;
717 uint8 b = (GPR (OP[1])) & 0xff;
718 uint8 tmp = (a + b + PSR_C) & 0xff;
719 trace_input ("addcb", OP_CONSTANT16, OP_REG, OP_VOID);
720 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
721 SET_PSR_C (tmp > 0xFF);
722 SET_PSR_F (((a & 0x80) == (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
723 trace_output_16 (sd, tmp);
724 }
725
726 /* addcb. */
727 void
728 OP_35_8 (SIM_DESC sd, SIM_CPU *cpu)
729 {
730 uint8 a = (GPR (OP[0])) & 0xff;
731 uint8 b = (GPR (OP[1])) & 0xff;
732 uint8 tmp = (a + b + PSR_C) & 0xff;
733 trace_input ("addcb", OP_REG, OP_REG, OP_VOID);
734 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
735 SET_PSR_C (tmp > 0xFF);
736 SET_PSR_F (((a & 0x80) == (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
737 trace_output_16 (sd, tmp);
738 }
739
740 /* addcw. */
741 void
742 OP_36_8 (SIM_DESC sd, SIM_CPU *cpu)
743 {
744 uint16 a = OP[0];
745 uint16 b = GPR (OP[1]);
746 uint16 tmp = (a + b + PSR_C);
747 trace_input ("addcw", OP_CONSTANT4_1, OP_REG, OP_VOID);
748 SET_GPR (OP[1], tmp);
749 SET_PSR_C (tmp > 0xFFFF);
750 SET_PSR_F (((a & 0x8000) == (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
751 trace_output_16 (sd, tmp);
752 }
753
754 /* addcw. */
755 void
756 OP_36B_C (SIM_DESC sd, SIM_CPU *cpu)
757 {
758 int16 a = OP[0];
759 uint16 b = GPR (OP[1]);
760 uint16 tmp = (a + b + PSR_C);
761 trace_input ("addcw", OP_CONSTANT16, OP_REG, OP_VOID);
762 SET_GPR (OP[1], tmp);
763 SET_PSR_C (tmp > 0xFFFF);
764 SET_PSR_F (((a & 0x8000) == (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
765 trace_output_16 (sd, tmp);
766 }
767
768 /* addcw. */
769 void
770 OP_37_8 (SIM_DESC sd, SIM_CPU *cpu)
771 {
772 uint16 a = GPR (OP[1]);
773 uint16 b = GPR (OP[1]);
774 uint16 tmp = (a + b + PSR_C);
775 trace_input ("addcw", OP_REG, OP_REG, OP_VOID);
776 SET_GPR (OP[1], tmp);
777 SET_PSR_C (tmp > 0xFFFF);
778 SET_PSR_F (((a & 0x8000) == (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
779 trace_output_16 (sd, tmp);
780 }
781
782 /* addd. */
783 void
784 OP_60_8 (SIM_DESC sd, SIM_CPU *cpu)
785 {
786 int16 a = (OP[0]);
787 uint32 b = GPR32 (OP[1]);
788 uint32 tmp = (a + b);
789 trace_input ("addd", OP_CONSTANT4_1, OP_REGP, OP_VOID);
790 SET_GPR32 (OP[1], tmp);
791 SET_PSR_C (tmp > 0xFFFFFFFF);
792 SET_PSR_F (((a & 0x80000000) == (b & 0x80000000)) && ((b & 0x80000000) != (tmp & 0x80000000)));
793 trace_output_32 (sd, tmp);
794 }
795
796 /* addd. */
797 void
798 OP_60B_C (SIM_DESC sd, SIM_CPU *cpu)
799 {
800 int32 a = (SEXT16(OP[0]));
801 uint32 b = GPR32 (OP[1]);
802 uint32 tmp = (a + b);
803 trace_input ("addd", OP_CONSTANT16, OP_REGP, OP_VOID);
804 SET_GPR32 (OP[1], tmp);
805 SET_PSR_C (tmp > 0xFFFFFFFF);
806 SET_PSR_F (((a & 0x80000000) == (b & 0x80000000)) && ((b & 0x80000000) != (tmp & 0x80000000)));
807 trace_output_32 (sd, tmp);
808 }
809
810 /* addd. */
811 void
812 OP_61_8 (SIM_DESC sd, SIM_CPU *cpu)
813 {
814 uint32 a = GPR32 (OP[0]);
815 uint32 b = GPR32 (OP[1]);
816 uint32 tmp = (a + b);
817 trace_input ("addd", OP_REGP, OP_REGP, OP_VOID);
818 SET_GPR32 (OP[1], tmp);
819 trace_output_32 (sd, tmp);
820 SET_PSR_C (tmp > 0xFFFFFFFF);
821 SET_PSR_F (((a & 0x80000000) == (b & 0x80000000)) && ((b & 0x80000000) != (tmp & 0x80000000)));
822 }
823
824 /* addd. */
825 void
826 OP_4_8 (SIM_DESC sd, SIM_CPU *cpu)
827 {
828 uint32 a = OP[0];
829 uint32 b = GPR32 (OP[1]);
830 uint32 tmp;
831 trace_input ("addd", OP_CONSTANT20, OP_REGP, OP_VOID);
832 tmp = (a + b);
833 SET_GPR32 (OP[1], tmp);
834 SET_PSR_C (tmp > 0xFFFFFFFF);
835 SET_PSR_F (((a & 0x80000000) == (b & 0x80000000)) && ((b & 0x80000000) != (tmp & 0x80000000)));
836 trace_output_32 (sd, tmp);
837 }
838
839 /* addd. */
840 void
841 OP_2_C (SIM_DESC sd, SIM_CPU *cpu)
842 {
843 int32 a = OP[0];
844 uint32 b = GPR32 (OP[1]);
845 uint32 tmp;
846 trace_input ("addd", OP_CONSTANT32, OP_REGP, OP_VOID);
847 tmp = (a + b);
848 SET_GPR32 (OP[1], tmp);
849 SET_PSR_C (tmp > 0xFFFFFFFF);
850 SET_PSR_F (((a & 0x80000000) == (b & 0x80000000)) && ((b & 0x80000000) != (tmp & 0x80000000)));
851 trace_output_32 (sd, tmp);
852 }
853
854 /* andb. */
855 void
856 OP_20_8 (SIM_DESC sd, SIM_CPU *cpu)
857 {
858 uint8 tmp, a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
859 trace_input ("andb", OP_CONSTANT4, OP_REG, OP_VOID);
860 tmp = a & b;
861 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
862 trace_output_16 (sd, tmp);
863 }
864
865 /* andb. */
866 void
867 OP_20B_C (SIM_DESC sd, SIM_CPU *cpu)
868 {
869 uint8 tmp, a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
870 trace_input ("andb", OP_CONSTANT16, OP_REG, OP_VOID);
871 tmp = a & b;
872 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
873 trace_output_16 (sd, tmp);
874 }
875
876 /* andb. */
877 void
878 OP_21_8 (SIM_DESC sd, SIM_CPU *cpu)
879 {
880 uint8 tmp, a = (GPR (OP[0])) & 0xff, b = (GPR (OP[1])) & 0xff;
881 trace_input ("andb", OP_REG, OP_REG, OP_VOID);
882 tmp = a & b;
883 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
884 trace_output_16 (sd, tmp);
885 }
886
887 /* andw. */
888 void
889 OP_22_8 (SIM_DESC sd, SIM_CPU *cpu)
890 {
891 uint16 tmp, a = OP[0], b = GPR (OP[1]);
892 trace_input ("andw", OP_CONSTANT4, OP_REG, OP_VOID);
893 tmp = a & b;
894 SET_GPR (OP[1], tmp);
895 trace_output_16 (sd, tmp);
896 }
897
898 /* andw. */
899 void
900 OP_22B_C (SIM_DESC sd, SIM_CPU *cpu)
901 {
902 uint16 tmp, a = OP[0], b = GPR (OP[1]);
903 trace_input ("andw", OP_CONSTANT16, OP_REG, OP_VOID);
904 tmp = a & b;
905 SET_GPR (OP[1], tmp);
906 trace_output_16 (sd, tmp);
907 }
908
909 /* andw. */
910 void
911 OP_23_8 (SIM_DESC sd, SIM_CPU *cpu)
912 {
913 uint16 tmp, a = GPR (OP[0]), b = GPR (OP[1]);
914 trace_input ("andw", OP_REG, OP_REG, OP_VOID);
915 tmp = a & b;
916 SET_GPR (OP[1], tmp);
917 trace_output_16 (sd, tmp);
918 }
919
920 /* andd. */
921 void
922 OP_4_C (SIM_DESC sd, SIM_CPU *cpu)
923 {
924 uint32 tmp, a = OP[0], b = GPR32 (OP[1]);
925 trace_input ("andd", OP_CONSTANT32, OP_REGP, OP_VOID);
926 tmp = a & b;
927 SET_GPR32 (OP[1], tmp);
928 trace_output_32 (sd, tmp);
929 }
930
931 /* andd. */
932 void
933 OP_14B_14 (SIM_DESC sd, SIM_CPU *cpu)
934 {
935 uint32 tmp, a = (GPR32 (OP[0])), b = (GPR32 (OP[1]));
936 trace_input ("andd", OP_REGP, OP_REGP, OP_VOID);
937 tmp = a & b;
938 SET_GPR32 (OP[1], tmp);
939 trace_output_32 (sd, tmp);
940 }
941
942 /* ord. */
943 void
944 OP_5_C (SIM_DESC sd, SIM_CPU *cpu)
945 {
946 uint32 tmp, a = (OP[0]), b = GPR32 (OP[1]);
947 trace_input ("ord", OP_CONSTANT32, OP_REG, OP_VOID);
948 tmp = a | b;
949 SET_GPR32 (OP[1], tmp);
950 trace_output_32 (sd, tmp);
951 }
952
953 /* ord. */
954 void
955 OP_149_14 (SIM_DESC sd, SIM_CPU *cpu)
956 {
957 uint32 tmp, a = GPR32 (OP[0]), b = GPR32 (OP[1]);
958 trace_input ("ord", OP_REGP, OP_REGP, OP_VOID);
959 tmp = a | b;
960 SET_GPR32 (OP[1], tmp);
961 trace_output_32 (sd, tmp);
962 }
963
964 /* xord. */
965 void
966 OP_6_C (SIM_DESC sd, SIM_CPU *cpu)
967 {
968 uint32 tmp, a = (OP[0]), b = GPR32 (OP[1]);
969 trace_input ("xord", OP_CONSTANT32, OP_REG, OP_VOID);
970 tmp = a ^ b;
971 SET_GPR32 (OP[1], tmp);
972 trace_output_32 (sd, tmp);
973 }
974
975 /* xord. */
976 void
977 OP_14A_14 (SIM_DESC sd, SIM_CPU *cpu)
978 {
979 uint32 tmp, a = GPR32 (OP[0]), b = GPR32 (OP[1]);
980 trace_input ("xord", OP_REGP, OP_REGP, OP_VOID);
981 tmp = a ^ b;
982 SET_GPR32 (OP[1], tmp);
983 trace_output_32 (sd, tmp);
984 }
985
986
987 /* b. */
988 void
989 OP_1_4 (SIM_DESC sd, SIM_CPU *cpu)
990 {
991 uint32 tmp = 0, cc = cond_stat (OP[0]);
992 trace_input ("b", OP_CONSTANT4, OP_DISPE9, OP_VOID);
993 if (cc)
994 {
995 if (sign_flag)
996 tmp = (PC - (OP[1]));
997 else
998 tmp = (PC + (OP[1]));
999 /* If the resulting PC value is less than 0x00_0000 or greater
1000 than 0xFF_FFFF, this instruction causes an IAD trap.*/
1001
1002 if ((tmp < 0x000000) || (tmp > 0xFFFFFF))
1003 {
1004 trace_output_void (sd);
1005 EXCEPTION (SIM_SIGBUS);
1006 }
1007 else
1008 JMP (tmp);
1009 }
1010 sign_flag = 0; /* Reset sign_flag. */
1011 trace_output_32 (sd, tmp);
1012 }
1013
1014 /* b. */
1015 void
1016 OP_18_8 (SIM_DESC sd, SIM_CPU *cpu)
1017 {
1018 uint32 tmp = 0, cc = cond_stat (OP[0]);
1019 trace_input ("b", OP_CONSTANT4, OP_DISP17, OP_VOID);
1020 if (cc)
1021 {
1022 if (sign_flag)
1023 tmp = (PC - OP[1]);
1024 else
1025 tmp = (PC + OP[1]);
1026 /* If the resulting PC value is less than 0x00_0000 or greater
1027 than 0xFF_FFFF, this instruction causes an IAD trap.*/
1028
1029 if ((tmp < 0x000000) || (tmp > 0xFFFFFF))
1030 {
1031 trace_output_void (sd);
1032 EXCEPTION (SIM_SIGBUS);
1033 }
1034 else
1035 JMP (tmp);
1036 }
1037 sign_flag = 0; /* Reset sign_flag. */
1038 trace_output_32 (sd, tmp);
1039 }
1040
1041 /* b. */
1042 void
1043 OP_10_10 (SIM_DESC sd, SIM_CPU *cpu)
1044 {
1045 uint32 tmp = 0, cc = cond_stat (OP[0]);
1046 trace_input ("b", OP_CONSTANT4, OP_DISP25, OP_VOID);
1047 if (cc)
1048 {
1049 if (sign_flag)
1050 tmp = (PC - (OP[1]));
1051 else
1052 tmp = (PC + (OP[1]));
1053 /* If the resulting PC value is less than 0x00_0000 or greater
1054 than 0xFF_FFFF, this instruction causes an IAD trap.*/
1055
1056 if ((tmp < 0x000000) || (tmp > 0xFFFFFF))
1057 {
1058 trace_output_void (sd);
1059 EXCEPTION (SIM_SIGBUS);
1060 }
1061 else
1062 JMP (tmp);
1063 }
1064 sign_flag = 0; /* Reset sign_flag. */
1065 trace_output_32 (sd, tmp);
1066 }
1067
1068 /* bal. */
1069 void
1070 OP_C0_8 (SIM_DESC sd, SIM_CPU *cpu)
1071 {
1072 uint32 tmp;
1073 trace_input ("bal", OP_REG, OP_DISP17, OP_VOID);
1074 tmp = ((PC + 4) >> 1); /* Store PC in RA register. */
1075 SET_GPR32 (14, tmp);
1076 if (sign_flag)
1077 tmp = (PC - (OP[1]));
1078 else
1079 tmp = (PC + (OP[1]));
1080
1081 /* If the resulting PC value is less than 0x00_0000 or greater
1082 than 0xFF_FFFF, this instruction causes an IAD trap. */
1083
1084 if ((tmp < 0x000000) || (tmp > 0xFFFFFF))
1085 {
1086 trace_output_void (sd);
1087 EXCEPTION (SIM_SIGBUS);
1088 }
1089 else
1090 JMP (tmp);
1091 sign_flag = 0; /* Reset sign_flag. */
1092 trace_output_32 (sd, tmp);
1093 }
1094
1095
1096 /* bal. */
1097 void
1098 OP_102_14 (SIM_DESC sd, SIM_CPU *cpu)
1099 {
1100 uint32 tmp;
1101 trace_input ("bal", OP_REGP, OP_DISP25, OP_VOID);
1102 tmp = (((PC) + 4) >> 1); /* Store PC in reg pair. */
1103 SET_GPR32 (OP[0], tmp);
1104 if (sign_flag)
1105 tmp = ((PC) - (OP[1]));
1106 else
1107 tmp = ((PC) + (OP[1]));
1108 /* If the resulting PC value is less than 0x00_0000 or greater
1109 than 0xFF_FFFF, this instruction causes an IAD trap.*/
1110
1111 if ((tmp < 0x000000) || (tmp > 0xFFFFFF))
1112 {
1113 trace_output_void (sd);
1114 EXCEPTION (SIM_SIGBUS);
1115 }
1116 else
1117 JMP (tmp);
1118 sign_flag = 0; /* Reset sign_flag. */
1119 trace_output_32 (sd, tmp);
1120 }
1121
1122 /* jal. */
1123 void
1124 OP_148_14 (SIM_DESC sd, SIM_CPU *cpu)
1125 {
1126 uint32 tmp;
1127 trace_input ("jal", OP_REGP, OP_REGP, OP_VOID);
1128 SET_GPR32 (OP[0], (((PC) + 4) >> 1)); /* Store next PC in RA */
1129 tmp = GPR32 (OP[1]);
1130 tmp = SEXT24(tmp << 1);
1131 /* If the resulting PC value is less than 0x00_0000 or greater
1132 than 0xFF_FFFF, this instruction causes an IAD trap.*/
1133
1134 if ((tmp < 0x0) || (tmp > 0xFFFFFF))
1135 {
1136 trace_output_void (sd);
1137 EXCEPTION (SIM_SIGBUS);
1138 }
1139 else
1140 JMP (tmp);
1141
1142 trace_output_32 (sd, tmp);
1143 }
1144
1145
1146 /* jal. */
1147 void
1148 OP_D_C (SIM_DESC sd, SIM_CPU *cpu)
1149 {
1150 uint32 tmp;
1151 trace_input ("jal", OP_REGP, OP_VOID, OP_VOID);
1152 SET_GPR32 (14, (((PC) + 2) >> 1)); /* Store next PC in RA */
1153 tmp = GPR32 (OP[0]);
1154 tmp = SEXT24(tmp << 1);
1155 /* If the resulting PC value is less than 0x00_0000 or greater
1156 than 0xFF_FFFF, this instruction causes an IAD trap.*/
1157
1158 if ((tmp < 0x0) || (tmp > 0xFFFFFF))
1159 {
1160 trace_output_void (sd);
1161 EXCEPTION (SIM_SIGBUS);
1162 }
1163 else
1164 JMP (tmp);
1165
1166 trace_output_32 (sd, tmp);
1167 }
1168
1169
1170 /* beq0b. */
1171 void
1172 OP_C_8 (SIM_DESC sd, SIM_CPU *cpu)
1173 {
1174 uint32 addr;
1175 uint8 a = (GPR (OP[0]) & 0xFF);
1176 trace_input ("beq0b", OP_REG, OP_DISP5, OP_VOID);
1177 addr = OP[1];
1178 if (a == 0)
1179 {
1180 if (sign_flag)
1181 addr = (PC - OP[1]);
1182 else
1183 addr = (PC + OP[1]);
1184
1185 JMP (addr);
1186 }
1187 sign_flag = 0; /* Reset sign_flag. */
1188 trace_output_void (sd);
1189 }
1190
1191 /* bne0b. */
1192 void
1193 OP_D_8 (SIM_DESC sd, SIM_CPU *cpu)
1194 {
1195 uint32 addr;
1196 uint8 a = (GPR (OP[0]) & 0xFF);
1197 trace_input ("bne0b", OP_REG, OP_DISP5, OP_VOID);
1198 addr = OP[1];
1199 if (a != 0)
1200 {
1201 if (sign_flag)
1202 addr = (PC - OP[1]);
1203 else
1204 addr = (PC + OP[1]);
1205
1206 JMP (addr);
1207 }
1208 sign_flag = 0; /* Reset sign_flag. */
1209 trace_output_void (sd);
1210 }
1211
1212 /* beq0w. */
1213 void
1214 OP_E_8 (SIM_DESC sd, SIM_CPU *cpu)
1215 {
1216 uint32 addr;
1217 uint16 a = GPR (OP[0]);
1218 trace_input ("beq0w", OP_REG, OP_DISP5, OP_VOID);
1219 addr = OP[1];
1220 if (a == 0)
1221 {
1222 if (sign_flag)
1223 addr = (PC - OP[1]);
1224 else
1225 addr = (PC + OP[1]);
1226
1227 JMP (addr);
1228 }
1229 sign_flag = 0; /* Reset sign_flag. */
1230 trace_output_void (sd);
1231 }
1232
1233 /* bne0w. */
1234 void
1235 OP_F_8 (SIM_DESC sd, SIM_CPU *cpu)
1236 {
1237 uint32 addr;
1238 uint16 a = GPR (OP[0]);
1239 trace_input ("bne0w", OP_REG, OP_DISP5, OP_VOID);
1240 addr = OP[1];
1241 if (a != 0)
1242 {
1243 if (sign_flag)
1244 addr = (PC - OP[1]);
1245 else
1246 addr = (PC + OP[1]);
1247
1248 JMP (addr);
1249 }
1250 sign_flag = 0; /* Reset sign_flag. */
1251 trace_output_void (sd);
1252 }
1253
1254
1255 /* jeq. */
1256 void
1257 OP_A0_C (SIM_DESC sd, SIM_CPU *cpu)
1258 {
1259 uint32 tmp = 0;
1260 trace_input ("jeq", OP_REGP, OP_VOID, OP_VOID);
1261 if ((PSR_Z) == 1)
1262 {
1263 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits. */
1264 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit. */
1265 }
1266 trace_output_32 (sd, tmp);
1267 }
1268
1269 /* jne. */
1270 void
1271 OP_A1_C (SIM_DESC sd, SIM_CPU *cpu)
1272 {
1273 uint32 tmp = 0;
1274 trace_input ("jne", OP_REGP, OP_VOID, OP_VOID);
1275 if ((PSR_Z) == 0)
1276 {
1277 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits. */
1278 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit. */
1279 }
1280 trace_output_32 (sd, tmp);
1281 }
1282
1283 /* jcs. */
1284 void
1285 OP_A2_C (SIM_DESC sd, SIM_CPU *cpu)
1286 {
1287 uint32 tmp = 0;
1288 trace_input ("jcs", OP_REGP, OP_VOID, OP_VOID);
1289 if ((PSR_C) == 1)
1290 {
1291 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1292 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1293 }
1294 trace_output_32 (sd, tmp);
1295 }
1296
1297 /* jcc. */
1298 void
1299 OP_A3_C (SIM_DESC sd, SIM_CPU *cpu)
1300 {
1301 uint32 tmp = 0;
1302 trace_input ("jcc", OP_REGP, OP_VOID, OP_VOID);
1303 if ((PSR_C) == 0)
1304 {
1305 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1306 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1307 }
1308 trace_output_32 (sd, tmp);
1309 }
1310
1311 /* jhi. */
1312 void
1313 OP_A4_C (SIM_DESC sd, SIM_CPU *cpu)
1314 {
1315 uint32 tmp = 0;
1316 trace_input ("jhi", OP_REGP, OP_VOID, OP_VOID);
1317 if ((PSR_L) == 1)
1318 {
1319 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1320 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1321 }
1322 trace_output_32 (sd, tmp);
1323 }
1324
1325 /* jls. */
1326 void
1327 OP_A5_C (SIM_DESC sd, SIM_CPU *cpu)
1328 {
1329 uint32 tmp = 0;
1330 trace_input ("jls", OP_REGP, OP_VOID, OP_VOID);
1331 if ((PSR_L) == 0)
1332 {
1333 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1334 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1335 }
1336 trace_output_32 (sd, tmp);
1337 }
1338
1339 /* jgt. */
1340 void
1341 OP_A6_C (SIM_DESC sd, SIM_CPU *cpu)
1342 {
1343 uint32 tmp = 0;
1344 trace_input ("jgt", OP_REGP, OP_VOID, OP_VOID);
1345 if ((PSR_N) == 1)
1346 {
1347 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1348 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1349 }
1350 trace_output_32 (sd, tmp);
1351 }
1352
1353 /* jle. */
1354 void
1355 OP_A7_C (SIM_DESC sd, SIM_CPU *cpu)
1356 {
1357 uint32 tmp = 0;
1358 trace_input ("jle", OP_REGP, OP_VOID, OP_VOID);
1359 if ((PSR_N) == 0)
1360 {
1361 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1362 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1363 }
1364 trace_output_32 (sd, tmp);
1365 }
1366
1367
1368 /* jfs. */
1369 void
1370 OP_A8_C (SIM_DESC sd, SIM_CPU *cpu)
1371 {
1372 uint32 tmp = 0;
1373 trace_input ("jfs", OP_REGP, OP_VOID, OP_VOID);
1374 if ((PSR_F) == 1)
1375 {
1376 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1377 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1378 }
1379 trace_output_32 (sd, tmp);
1380 }
1381
1382 /* jfc. */
1383 void
1384 OP_A9_C (SIM_DESC sd, SIM_CPU *cpu)
1385 {
1386 uint32 tmp = 0;
1387 trace_input ("jfc", OP_REGP, OP_VOID, OP_VOID);
1388 if ((PSR_F) == 0)
1389 {
1390 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1391 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1392 }
1393 trace_output_32 (sd, tmp);
1394 }
1395
1396 /* jlo. */
1397 void
1398 OP_AA_C (SIM_DESC sd, SIM_CPU *cpu)
1399 {
1400 uint32 tmp = 0;
1401 trace_input ("jlo", OP_REGP, OP_VOID, OP_VOID);
1402 if (((PSR_Z) == 0) & ((PSR_L) == 0))
1403 {
1404 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1405 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1406 }
1407 trace_output_32 (sd, tmp);
1408 }
1409
1410 /* jhs. */
1411 void
1412 OP_AB_C (SIM_DESC sd, SIM_CPU *cpu)
1413 {
1414 uint32 tmp = 0;
1415 trace_input ("jhs", OP_REGP, OP_VOID, OP_VOID);
1416 if (((PSR_Z) == 1) | ((PSR_L) == 1))
1417 {
1418 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1419 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1420 }
1421 trace_output_32 (sd, tmp);
1422 }
1423
1424 /* jlt. */
1425 void
1426 OP_AC_C (SIM_DESC sd, SIM_CPU *cpu)
1427 {
1428 uint32 tmp = 0;
1429 trace_input ("jlt", OP_REGP, OP_VOID, OP_VOID);
1430 if (((PSR_Z) == 0) & ((PSR_N) == 0))
1431 {
1432 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1433 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1434 }
1435 trace_output_32 (sd, tmp);
1436 }
1437
1438 /* jge. */
1439 void
1440 OP_AD_C (SIM_DESC sd, SIM_CPU *cpu)
1441 {
1442 uint32 tmp = 0;
1443 trace_input ("jge", OP_REGP, OP_VOID, OP_VOID);
1444 if (((PSR_Z) == 1) | ((PSR_N) == 1))
1445 {
1446 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1447 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1448 }
1449 trace_output_32 (sd, tmp);
1450 }
1451
1452 /* jump. */
1453 void
1454 OP_AE_C (SIM_DESC sd, SIM_CPU *cpu)
1455 {
1456 uint32 tmp;
1457 trace_input ("jump", OP_REGP, OP_VOID, OP_VOID);
1458 tmp = GPR32 (OP[0]) /*& 0x3fffff*/; /* Use only 0 - 22 bits */
1459 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1460 trace_output_32 (sd, tmp);
1461 }
1462
1463 /* jusr. */
1464 void
1465 OP_AF_C (SIM_DESC sd, SIM_CPU *cpu)
1466 {
1467 uint32 tmp;
1468 trace_input ("jusr", OP_REGP, OP_VOID, OP_VOID);
1469 tmp = (GPR32 (OP[0])) & 0x3fffff; /* Use only 0 - 22 bits */
1470 JMP (tmp << 1); /* Set PC's 1 - 23 bits and clear 0th bit*/
1471 SET_PSR_U(1);
1472 trace_output_32 (sd, tmp);
1473 }
1474
1475 /* seq. */
1476 void
1477 OP_80_C (SIM_DESC sd, SIM_CPU *cpu)
1478 {
1479 trace_input ("seq", OP_REG, OP_VOID, OP_VOID);
1480 if ((PSR_Z) == 1)
1481 SET_GPR (OP[0], 1);
1482 else
1483 SET_GPR (OP[0], 0);
1484 trace_output_void (sd);
1485 }
1486 /* sne. */
1487 void
1488 OP_81_C (SIM_DESC sd, SIM_CPU *cpu)
1489 {
1490 trace_input ("sne", OP_REG, OP_VOID, OP_VOID);
1491 if ((PSR_Z) == 0)
1492 SET_GPR (OP[0], 1);
1493 else
1494 SET_GPR (OP[0], 0);
1495 trace_output_void (sd);
1496 }
1497
1498 /* scs. */
1499 void
1500 OP_82_C (SIM_DESC sd, SIM_CPU *cpu)
1501 {
1502 trace_input ("scs", OP_REG, OP_VOID, OP_VOID);
1503 if ((PSR_C) == 1)
1504 SET_GPR (OP[0], 1);
1505 else
1506 SET_GPR (OP[0], 0);
1507 trace_output_void (sd);
1508 }
1509
1510 /* scc. */
1511 void
1512 OP_83_C (SIM_DESC sd, SIM_CPU *cpu)
1513 {
1514 trace_input ("scc", OP_REG, OP_VOID, OP_VOID);
1515 if ((PSR_C) == 0)
1516 SET_GPR (OP[0], 1);
1517 else
1518 SET_GPR (OP[0], 0);
1519 trace_output_void (sd);
1520 }
1521
1522 /* shi. */
1523 void
1524 OP_84_C (SIM_DESC sd, SIM_CPU *cpu)
1525 {
1526 trace_input ("shi", OP_REG, OP_VOID, OP_VOID);
1527 if ((PSR_L) == 1)
1528 SET_GPR (OP[0], 1);
1529 else
1530 SET_GPR (OP[0], 0);
1531 trace_output_void (sd);
1532 }
1533
1534 /* sls. */
1535 void
1536 OP_85_C (SIM_DESC sd, SIM_CPU *cpu)
1537 {
1538 trace_input ("sls", OP_REG, OP_VOID, OP_VOID);
1539 if ((PSR_L) == 0)
1540 SET_GPR (OP[0], 1);
1541 else
1542 SET_GPR (OP[0], 0);
1543 trace_output_void (sd);
1544 }
1545
1546 /* sgt. */
1547 void
1548 OP_86_C (SIM_DESC sd, SIM_CPU *cpu)
1549 {
1550 trace_input ("sgt", OP_REG, OP_VOID, OP_VOID);
1551 if ((PSR_N) == 1)
1552 SET_GPR (OP[0], 1);
1553 else
1554 SET_GPR (OP[0], 0);
1555 trace_output_void (sd);
1556 }
1557
1558 /* sle. */
1559 void
1560 OP_87_C (SIM_DESC sd, SIM_CPU *cpu)
1561 {
1562 trace_input ("sle", OP_REG, OP_VOID, OP_VOID);
1563 if ((PSR_N) == 0)
1564 SET_GPR (OP[0], 1);
1565 else
1566 SET_GPR (OP[0], 0);
1567 trace_output_void (sd);
1568 }
1569
1570 /* sfs. */
1571 void
1572 OP_88_C (SIM_DESC sd, SIM_CPU *cpu)
1573 {
1574 trace_input ("sfs", OP_REG, OP_VOID, OP_VOID);
1575 if ((PSR_F) == 1)
1576 SET_GPR (OP[0], 1);
1577 else
1578 SET_GPR (OP[0], 0);
1579 trace_output_void (sd);
1580 }
1581
1582 /* sfc. */
1583 void
1584 OP_89_C (SIM_DESC sd, SIM_CPU *cpu)
1585 {
1586 trace_input ("sfc", OP_REG, OP_VOID, OP_VOID);
1587 if ((PSR_F) == 0)
1588 SET_GPR (OP[0], 1);
1589 else
1590 SET_GPR (OP[0], 0);
1591 trace_output_void (sd);
1592 }
1593
1594
1595 /* slo. */
1596 void
1597 OP_8A_C (SIM_DESC sd, SIM_CPU *cpu)
1598 {
1599 trace_input ("slo", OP_REG, OP_VOID, OP_VOID);
1600 if (((PSR_Z) == 0) & ((PSR_L) == 0))
1601 SET_GPR (OP[0], 1);
1602 else
1603 SET_GPR (OP[0], 0);
1604 trace_output_void (sd);
1605 }
1606
1607 /* shs. */
1608 void
1609 OP_8B_C (SIM_DESC sd, SIM_CPU *cpu)
1610 {
1611 trace_input ("shs", OP_REG, OP_VOID, OP_VOID);
1612 if ( ((PSR_Z) == 1) | ((PSR_L) == 1))
1613 SET_GPR (OP[0], 1);
1614 else
1615 SET_GPR (OP[0], 0);
1616 trace_output_void (sd);
1617 }
1618
1619 /* slt. */
1620 void
1621 OP_8C_C (SIM_DESC sd, SIM_CPU *cpu)
1622 {
1623 trace_input ("slt", OP_REG, OP_VOID, OP_VOID);
1624 if (((PSR_Z) == 0) & ((PSR_N) == 0))
1625 SET_GPR (OP[0], 1);
1626 else
1627 SET_GPR (OP[0], 0);
1628 trace_output_void (sd);
1629 }
1630
1631 /* sge. */
1632 void
1633 OP_8D_C (SIM_DESC sd, SIM_CPU *cpu)
1634 {
1635 trace_input ("sge", OP_REG, OP_VOID, OP_VOID);
1636 if (((PSR_Z) == 1) | ((PSR_N) == 1))
1637 SET_GPR (OP[0], 1);
1638 else
1639 SET_GPR (OP[0], 0);
1640 trace_output_void (sd);
1641 }
1642
1643 /* cbitb. */
1644 void
1645 OP_D7_9 (SIM_DESC sd, SIM_CPU *cpu)
1646 {
1647 uint8 a = OP[0] & 0xff;
1648 uint32 addr = OP[1], tmp;
1649 trace_input ("cbitb", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
1650 tmp = RB (addr);
1651 SET_PSR_F (tmp & (1 << a));
1652 tmp = tmp & ~(1 << a);
1653 SB (addr, tmp);
1654 trace_output_32 (sd, tmp);
1655 }
1656
1657 /* cbitb. */
1658 void
1659 OP_107_14 (SIM_DESC sd, SIM_CPU *cpu)
1660 {
1661 uint8 a = OP[0] & 0xff;
1662 uint32 addr = OP[1], tmp;
1663 trace_input ("cbitb", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
1664 tmp = RB (addr);
1665 SET_PSR_F (tmp & (1 << a));
1666 tmp = tmp & ~(1 << a);
1667 SB (addr, tmp);
1668 trace_output_32 (sd, tmp);
1669 }
1670
1671 /* cbitb. */
1672 void
1673 OP_68_8 (SIM_DESC sd, SIM_CPU *cpu)
1674 {
1675 uint8 a = (OP[0]) & 0xff;
1676 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
1677 trace_input ("cbitb", OP_CONSTANT4, OP_R_INDEX7_ABS20, OP_VOID);
1678 tmp = RB (addr);
1679 SET_PSR_F (tmp & (1 << a));
1680 tmp = tmp & ~(1 << a);
1681 SB (addr, tmp);
1682 trace_output_32 (sd, addr);
1683 }
1684
1685 /* cbitb. */
1686 void
1687 OP_1AA_A (SIM_DESC sd, SIM_CPU *cpu)
1688 {
1689 uint8 a = (OP[0]) & 0xff;
1690 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1691 trace_input ("cbitb", OP_CONSTANT4, OP_RP_INDEX_DISP14, OP_VOID);
1692 tmp = RB (addr);
1693 SET_PSR_F (tmp & (1 << a));
1694 tmp = tmp & ~(1 << a);
1695 SB (addr, tmp);
1696 trace_output_32 (sd, addr);
1697 }
1698
1699 /* cbitb. */
1700 void
1701 OP_104_14 (SIM_DESC sd, SIM_CPU *cpu)
1702 {
1703 uint8 a = (OP[0]) & 0xff;
1704 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
1705 trace_input ("cbitb", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
1706 tmp = RB (addr);
1707 SET_PSR_F (tmp & (1 << a));
1708 tmp = tmp & ~(1 << a);
1709 SB (addr, tmp);
1710 trace_output_32 (sd, addr);
1711 }
1712
1713 /* cbitb. */
1714 void
1715 OP_D4_9 (SIM_DESC sd, SIM_CPU *cpu)
1716 {
1717 uint8 a = (OP[0]) & 0xff;
1718 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1719 trace_input ("cbitb", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
1720 tmp = RB (addr);
1721 SET_PSR_F (tmp & (1 << a));
1722 tmp = tmp & ~(1 << a);
1723 SB (addr, tmp);
1724 trace_output_32 (sd, addr);
1725 }
1726
1727 /* cbitb. */
1728 void
1729 OP_D6_9 (SIM_DESC sd, SIM_CPU *cpu)
1730 {
1731 uint8 a = (OP[0]) & 0xff;
1732 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1733 trace_input ("cbitb", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
1734 tmp = RB (addr);
1735 SET_PSR_F (tmp & (1 << a));
1736 tmp = tmp & ~(1 << a);
1737 SB (addr, tmp);
1738 trace_output_32 (sd, addr);
1739
1740 }
1741
1742 /* cbitb. */
1743 void
1744 OP_105_14 (SIM_DESC sd, SIM_CPU *cpu)
1745 {
1746 uint8 a = (OP[0]) & 0xff;
1747 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1748 trace_input ("cbitb", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
1749 tmp = RB (addr);
1750 SET_PSR_F (tmp & (1 << a));
1751 tmp = tmp & ~(1 << a);
1752 SB (addr, tmp);
1753 trace_output_32 (sd, addr);
1754 }
1755
1756 /* cbitb. */
1757 void
1758 OP_106_14 (SIM_DESC sd, SIM_CPU *cpu)
1759 {
1760 uint8 a = (OP[0]) & 0xff;
1761 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1762 trace_input ("cbitb", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
1763 tmp = RB (addr);
1764 SET_PSR_F (tmp & (1 << a));
1765 tmp = tmp & ~(1 << a);
1766 SB (addr, tmp);
1767 trace_output_32 (sd, addr);
1768 }
1769
1770
1771 /* cbitw. */
1772 void
1773 OP_6F_8 (SIM_DESC sd, SIM_CPU *cpu)
1774 {
1775 uint16 a = OP[0];
1776 uint32 addr = OP[1], tmp;
1777 trace_input ("cbitw", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
1778 tmp = RW (addr);
1779 SET_PSR_F (tmp & (1 << a));
1780 tmp = tmp & ~(1 << a);
1781 SW (addr, tmp);
1782 trace_output_32 (sd, tmp);
1783 }
1784
1785 /* cbitw. */
1786 void
1787 OP_117_14 (SIM_DESC sd, SIM_CPU *cpu)
1788 {
1789 uint16 a = OP[0];
1790 uint32 addr = OP[1], tmp;
1791 trace_input ("cbitw", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
1792 tmp = RW (addr);
1793 SET_PSR_F (tmp & (1 << a));
1794 tmp = tmp & ~(1 << a);
1795 SW (addr, tmp);
1796 trace_output_32 (sd, tmp);
1797 }
1798
1799 /* cbitw. */
1800 void
1801 OP_36_7 (SIM_DESC sd, SIM_CPU *cpu)
1802 {
1803 uint32 addr;
1804 uint16 a = (OP[0]), tmp;
1805 trace_input ("cbitw", OP_CONSTANT4, OP_R_INDEX8_ABS20, OP_VOID);
1806
1807 if (OP[1] == 0)
1808 addr = (GPR32 (12)) + OP[2];
1809 else
1810 addr = (GPR32 (13)) + OP[2];
1811
1812 tmp = RW (addr);
1813 SET_PSR_F (tmp & (1 << a));
1814 tmp = tmp & ~(1 << a);
1815 SW (addr, tmp);
1816 trace_output_32 (sd, addr);
1817
1818 }
1819
1820 /* cbitw. */
1821 void
1822 OP_1AB_A (SIM_DESC sd, SIM_CPU *cpu)
1823 {
1824 uint16 a = (OP[0]);
1825 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1826 trace_input ("cbitw", OP_CONSTANT4, OP_RP_INDEX_DISP14, OP_VOID);
1827 tmp = RW (addr);
1828 SET_PSR_F (tmp & (1 << a));
1829 tmp = tmp & ~(1 << a);
1830 SW (addr, tmp);
1831 trace_output_32 (sd, addr);
1832 }
1833
1834 /* cbitw. */
1835 void
1836 OP_114_14 (SIM_DESC sd, SIM_CPU *cpu)
1837 {
1838 uint16 a = (OP[0]);
1839 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
1840 trace_input ("cbitw", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
1841 tmp = RW (addr);
1842 SET_PSR_F (tmp & (1 << a));
1843 tmp = tmp & ~(1 << a);
1844 SW (addr, tmp);
1845 trace_output_32 (sd, addr);
1846 }
1847
1848
1849 /* cbitw. */
1850 void
1851 OP_6E_8 (SIM_DESC sd, SIM_CPU *cpu)
1852 {
1853 uint16 a = (OP[0]);
1854 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1855 trace_input ("cbitw", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
1856 tmp = RW (addr);
1857 SET_PSR_F (tmp & (1 << a));
1858 tmp = tmp & ~(1 << a);
1859 SW (addr, tmp);
1860 trace_output_32 (sd, addr);
1861 }
1862
1863 /* cbitw. */
1864 void
1865 OP_69_8 (SIM_DESC sd, SIM_CPU *cpu)
1866 {
1867 uint16 a = (OP[0]);
1868 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1869 trace_input ("cbitw", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
1870 tmp = RW (addr);
1871 SET_PSR_F (tmp & (1 << a));
1872 tmp = tmp & ~(1 << a);
1873 SW (addr, tmp);
1874 trace_output_32 (sd, addr);
1875 }
1876
1877
1878 /* cbitw. */
1879 void
1880 OP_115_14 (SIM_DESC sd, SIM_CPU *cpu)
1881 {
1882 uint16 a = (OP[0]);
1883 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1884 trace_input ("cbitw", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
1885 tmp = RW (addr);
1886 SET_PSR_F (tmp & (1 << a));
1887 tmp = tmp & ~(1 << a);
1888 SW (addr, tmp);
1889 trace_output_32 (sd, addr);
1890 }
1891
1892 /* cbitw. */
1893 void
1894 OP_116_14 (SIM_DESC sd, SIM_CPU *cpu)
1895 {
1896 uint16 a = (OP[0]);
1897 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1898 trace_input ("cbitw", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
1899 tmp = RW (addr);
1900 SET_PSR_F (tmp & (1 << a));
1901 tmp = tmp & ~(1 << a);
1902 SW (addr, tmp);
1903 trace_output_32 (sd, addr);
1904 }
1905
1906 /* sbitb. */
1907 void
1908 OP_E7_9 (SIM_DESC sd, SIM_CPU *cpu)
1909 {
1910 uint8 a = OP[0] & 0xff;
1911 uint32 addr = OP[1], tmp;
1912 trace_input ("sbitb", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
1913 tmp = RB (addr);
1914 SET_PSR_F (tmp & (1 << a));
1915 tmp = tmp | (1 << a);
1916 SB (addr, tmp);
1917 trace_output_32 (sd, tmp);
1918 }
1919
1920 /* sbitb. */
1921 void
1922 OP_10B_14 (SIM_DESC sd, SIM_CPU *cpu)
1923 {
1924 uint8 a = OP[0] & 0xff;
1925 uint32 addr = OP[1], tmp;
1926 trace_input ("sbitb", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
1927 tmp = RB (addr);
1928 SET_PSR_F (tmp & (1 << a));
1929 tmp = tmp | (1 << a);
1930 SB (addr, tmp);
1931 trace_output_32 (sd, tmp);
1932 }
1933
1934 /* sbitb. */
1935 void
1936 OP_70_8 (SIM_DESC sd, SIM_CPU *cpu)
1937 {
1938 uint8 a = OP[0] & 0xff;
1939 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
1940 trace_input ("sbitb", OP_CONSTANT4, OP_R_INDEX7_ABS20, OP_VOID);
1941 tmp = RB (addr);
1942 SET_PSR_F (tmp & (1 << a));
1943 tmp = tmp | (1 << a);
1944 SB (addr, tmp);
1945 trace_output_32 (sd, tmp);
1946 }
1947
1948 /* sbitb. */
1949 void
1950 OP_1CA_A (SIM_DESC sd, SIM_CPU *cpu)
1951 {
1952 uint8 a = OP[0] & 0xff;
1953 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1954 trace_input ("sbitb", OP_CONSTANT4, OP_RP_INDEX_DISP14, OP_VOID);
1955 tmp = RB (addr);
1956 SET_PSR_F (tmp & (1 << a));
1957 tmp = tmp | (1 << a);
1958 SB (addr, tmp);
1959 trace_output_32 (sd, tmp);
1960 }
1961
1962 /* sbitb. */
1963 void
1964 OP_108_14 (SIM_DESC sd, SIM_CPU *cpu)
1965 {
1966 uint8 a = OP[0] & 0xff;
1967 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
1968 trace_input ("sbitb", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
1969 tmp = RB (addr);
1970 SET_PSR_F (tmp & (1 << a));
1971 tmp = tmp | (1 << a);
1972 SB (addr, tmp);
1973 trace_output_32 (sd, tmp);
1974 }
1975
1976
1977 /* sbitb. */
1978 void
1979 OP_E4_9 (SIM_DESC sd, SIM_CPU *cpu)
1980 {
1981 uint8 a = OP[0] & 0xff;
1982 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1983 trace_input ("sbitb", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
1984 tmp = RB (addr);
1985 SET_PSR_F (tmp & (1 << a));
1986 tmp = tmp | (1 << a);
1987 SB (addr, tmp);
1988 trace_output_32 (sd, tmp);
1989 }
1990
1991 /* sbitb. */
1992 void
1993 OP_E6_9 (SIM_DESC sd, SIM_CPU *cpu)
1994 {
1995 uint8 a = OP[0] & 0xff;
1996 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
1997 trace_input ("sbitb", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
1998 tmp = RB (addr);
1999 SET_PSR_F (tmp & (1 << a));
2000 tmp = tmp | (1 << a);
2001 SB (addr, tmp);
2002 trace_output_32 (sd, tmp);
2003 }
2004
2005
2006 /* sbitb. */
2007 void
2008 OP_109_14 (SIM_DESC sd, SIM_CPU *cpu)
2009 {
2010 uint8 a = OP[0] & 0xff;
2011 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2012 trace_input ("sbitb", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
2013 tmp = RB (addr);
2014 SET_PSR_F (tmp & (1 << a));
2015 tmp = tmp | (1 << a);
2016 SB (addr, tmp);
2017 trace_output_32 (sd, tmp);
2018 }
2019
2020
2021 /* sbitb. */
2022 void
2023 OP_10A_14 (SIM_DESC sd, SIM_CPU *cpu)
2024 {
2025 uint8 a = OP[0] & 0xff;
2026 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2027 trace_input ("sbitb", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
2028 tmp = RB (addr);
2029 SET_PSR_F (tmp & (1 << a));
2030 tmp = tmp | (1 << a);
2031 SB (addr, tmp);
2032 trace_output_32 (sd, tmp);
2033 }
2034
2035
2036 /* sbitw. */
2037 void
2038 OP_77_8 (SIM_DESC sd, SIM_CPU *cpu)
2039 {
2040 uint16 a = OP[0];
2041 uint32 addr = OP[1], tmp;
2042 trace_input ("sbitw", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
2043 tmp = RW (addr);
2044 SET_PSR_F (tmp & (1 << a));
2045 tmp = tmp | (1 << a);
2046 SW (addr, tmp);
2047 trace_output_32 (sd, tmp);
2048 }
2049
2050 /* sbitw. */
2051 void
2052 OP_11B_14 (SIM_DESC sd, SIM_CPU *cpu)
2053 {
2054 uint16 a = OP[0];
2055 uint32 addr = OP[1], tmp;
2056 trace_input ("sbitw", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
2057 tmp = RW (addr);
2058 SET_PSR_F (tmp & (1 << a));
2059 tmp = tmp | (1 << a);
2060 SW (addr, tmp);
2061 trace_output_32 (sd, tmp);
2062 }
2063
2064 /* sbitw. */
2065 void
2066 OP_3A_7 (SIM_DESC sd, SIM_CPU *cpu)
2067 {
2068 uint32 addr;
2069 uint16 a = (OP[0]), tmp;
2070 trace_input ("sbitw", OP_CONSTANT4, OP_R_INDEX8_ABS20, OP_VOID);
2071
2072 if (OP[1] == 0)
2073 addr = (GPR32 (12)) + OP[2];
2074 else
2075 addr = (GPR32 (13)) + OP[2];
2076
2077 tmp = RW (addr);
2078 SET_PSR_F (tmp & (1 << a));
2079 tmp = tmp | (1 << a);
2080 SW (addr, tmp);
2081 trace_output_32 (sd, addr);
2082 }
2083
2084 /* sbitw. */
2085 void
2086 OP_1CB_A (SIM_DESC sd, SIM_CPU *cpu)
2087 {
2088 uint16 a = (OP[0]);
2089 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2090 trace_input ("sbitw", OP_CONSTANT4, OP_RP_INDEX_DISP14, OP_VOID);
2091 tmp = RW (addr);
2092 SET_PSR_F (tmp & (1 << a));
2093 tmp = tmp | (1 << a);
2094 SW (addr, tmp);
2095 trace_output_32 (sd, addr);
2096 }
2097
2098 /* sbitw. */
2099 void
2100 OP_118_14 (SIM_DESC sd, SIM_CPU *cpu)
2101 {
2102 uint16 a = (OP[0]);
2103 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
2104 trace_input ("sbitw", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
2105 tmp = RW (addr);
2106 SET_PSR_F (tmp & (1 << a));
2107 tmp = tmp | (1 << a);
2108 SW (addr, tmp);
2109 trace_output_32 (sd, addr);
2110 }
2111
2112 /* sbitw. */
2113 void
2114 OP_76_8 (SIM_DESC sd, SIM_CPU *cpu)
2115 {
2116 uint16 a = (OP[0]);
2117 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2118 trace_input ("sbitw", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
2119 tmp = RW (addr);
2120 SET_PSR_F (tmp & (1 << a));
2121 tmp = tmp | (1 << a);
2122 SW (addr, tmp);
2123 trace_output_32 (sd, addr);
2124 }
2125
2126 /* sbitw. */
2127 void
2128 OP_71_8 (SIM_DESC sd, SIM_CPU *cpu)
2129 {
2130 uint16 a = (OP[0]);
2131 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2132 trace_input ("sbitw", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
2133 tmp = RW (addr);
2134 SET_PSR_F (tmp & (1 << a));
2135 tmp = tmp | (1 << a);
2136 SW (addr, tmp);
2137 trace_output_32 (sd, addr);
2138 }
2139
2140 /* sbitw. */
2141 void
2142 OP_119_14 (SIM_DESC sd, SIM_CPU *cpu)
2143 {
2144 uint16 a = (OP[0]);
2145 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2146 trace_input ("sbitw", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
2147 tmp = RW (addr);
2148 SET_PSR_F (tmp & (1 << a));
2149 tmp = tmp | (1 << a);
2150 SW (addr, tmp);
2151 trace_output_32 (sd, addr);
2152 }
2153
2154 /* sbitw. */
2155 void
2156 OP_11A_14 (SIM_DESC sd, SIM_CPU *cpu)
2157 {
2158 uint16 a = (OP[0]);
2159 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2160 trace_input ("sbitw", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
2161 tmp = RW (addr);
2162 SET_PSR_F (tmp & (1 << a));
2163 tmp = tmp | (1 << a);
2164 SW (addr, tmp);
2165 trace_output_32 (sd, addr);
2166 }
2167
2168
2169 /* tbitb. */
2170 void
2171 OP_F7_9 (SIM_DESC sd, SIM_CPU *cpu)
2172 {
2173 uint8 a = OP[0] & 0xff;
2174 uint32 addr = OP[1], tmp;
2175 trace_input ("tbitb", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
2176 tmp = RB (addr);
2177 SET_PSR_F (tmp & (1 << a));
2178 trace_output_32 (sd, tmp);
2179 }
2180
2181 /* tbitb. */
2182 void
2183 OP_10F_14 (SIM_DESC sd, SIM_CPU *cpu)
2184 {
2185 uint8 a = OP[0] & 0xff;
2186 uint32 addr = OP[1], tmp;
2187 trace_input ("tbitb", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
2188 tmp = RB (addr);
2189 SET_PSR_F (tmp & (1 << a));
2190 trace_output_32 (sd, tmp);
2191 }
2192
2193 /* tbitb. */
2194 void
2195 OP_78_8 (SIM_DESC sd, SIM_CPU *cpu)
2196 {
2197 uint8 a = (OP[0]) & 0xff;
2198 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
2199 trace_input ("tbitb", OP_CONSTANT4, OP_R_INDEX7_ABS20, OP_VOID);
2200 tmp = RB (addr);
2201 SET_PSR_F (tmp & (1 << a));
2202 trace_output_32 (sd, addr);
2203 }
2204
2205 /* tbitb. */
2206 void
2207 OP_1EA_A (SIM_DESC sd, SIM_CPU *cpu)
2208 {
2209 uint8 a = (OP[0]) & 0xff;
2210 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2211 trace_input ("tbitb", OP_CONSTANT4, OP_RP_INDEX_DISP14, OP_VOID);
2212 tmp = RB (addr);
2213 SET_PSR_F (tmp & (1 << a));
2214 trace_output_32 (sd, addr);
2215 }
2216
2217 /* tbitb. */
2218 void
2219 OP_10C_14 (SIM_DESC sd, SIM_CPU *cpu)
2220 {
2221 uint8 a = (OP[0]) & 0xff;
2222 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
2223 trace_input ("tbitb", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
2224 tmp = RB (addr);
2225 SET_PSR_F (tmp & (1 << a));
2226 trace_output_32 (sd, addr);
2227 }
2228
2229 /* tbitb. */
2230 void
2231 OP_F4_9 (SIM_DESC sd, SIM_CPU *cpu)
2232 {
2233 uint8 a = (OP[0]) & 0xff;
2234 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2235 trace_input ("tbitb", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
2236 tmp = RB (addr);
2237 SET_PSR_F (tmp & (1 << a));
2238 trace_output_32 (sd, addr);
2239 }
2240
2241 /* tbitb. */
2242 void
2243 OP_F6_9 (SIM_DESC sd, SIM_CPU *cpu)
2244 {
2245 uint8 a = (OP[0]) & 0xff;
2246 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2247 trace_input ("tbitb", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
2248 tmp = RB (addr);
2249 SET_PSR_F (tmp & (1 << a));
2250 trace_output_32 (sd, addr);
2251 }
2252
2253 /* tbitb. */
2254 void
2255 OP_10D_14 (SIM_DESC sd, SIM_CPU *cpu)
2256 {
2257 uint8 a = (OP[0]) & 0xff;
2258 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2259 trace_input ("tbitb", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
2260 tmp = RB (addr);
2261 SET_PSR_F (tmp & (1 << a));
2262 trace_output_32 (sd, addr);
2263 }
2264
2265 /* tbitb. */
2266 void
2267 OP_10E_14 (SIM_DESC sd, SIM_CPU *cpu)
2268 {
2269 uint8 a = (OP[0]) & 0xff;
2270 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2271 trace_input ("tbitb", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
2272 tmp = RB (addr);
2273 SET_PSR_F (tmp & (1 << a));
2274 trace_output_32 (sd, addr);
2275 }
2276
2277
2278 /* tbitw. */
2279 void
2280 OP_7F_8 (SIM_DESC sd, SIM_CPU *cpu)
2281 {
2282 uint16 a = OP[0];
2283 uint32 addr = OP[1], tmp;
2284 trace_input ("tbitw", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
2285 tmp = RW (addr);
2286 SET_PSR_F (tmp & (1 << a));
2287 trace_output_32 (sd, tmp);
2288 }
2289
2290 /* tbitw. */
2291 void
2292 OP_11F_14 (SIM_DESC sd, SIM_CPU *cpu)
2293 {
2294 uint16 a = OP[0];
2295 uint32 addr = OP[1], tmp;
2296 trace_input ("tbitw", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
2297 tmp = RW (addr);
2298 SET_PSR_F (tmp & (1 << a));
2299 trace_output_32 (sd, tmp);
2300 }
2301
2302
2303 /* tbitw. */
2304 void
2305 OP_3E_7 (SIM_DESC sd, SIM_CPU *cpu)
2306 {
2307 uint32 addr;
2308 uint16 a = (OP[0]), tmp;
2309 trace_input ("tbitw", OP_CONSTANT4, OP_R_INDEX8_ABS20, OP_VOID);
2310
2311 if (OP[1] == 0)
2312 addr = (GPR32 (12)) + OP[2];
2313 else
2314 addr = (GPR32 (13)) + OP[2];
2315
2316 tmp = RW (addr);
2317 SET_PSR_F (tmp & (1 << a));
2318 trace_output_32 (sd, addr);
2319 }
2320
2321 /* tbitw. */
2322 void
2323 OP_1EB_A (SIM_DESC sd, SIM_CPU *cpu)
2324 {
2325 uint16 a = (OP[0]);
2326 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2327 trace_input ("tbitw", OP_CONSTANT4, OP_RP_INDEX_DISP14, OP_VOID);
2328 tmp = RW (addr);
2329 SET_PSR_F (tmp & (1 << a));
2330 trace_output_32 (sd, addr);
2331 }
2332
2333 /* tbitw. */
2334 void
2335 OP_11C_14 (SIM_DESC sd, SIM_CPU *cpu)
2336 {
2337 uint16 a = (OP[0]);
2338 uint32 addr = (GPR (OP[2])) + OP[1], tmp;
2339 trace_input ("tbitw", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
2340 tmp = RW (addr);
2341 SET_PSR_F (tmp & (1 << a));
2342 trace_output_32 (sd, addr);
2343 }
2344
2345 /* tbitw. */
2346 void
2347 OP_7E_8 (SIM_DESC sd, SIM_CPU *cpu)
2348 {
2349 uint16 a = (OP[0]);
2350 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2351 trace_input ("tbitw", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
2352 tmp = RW (addr);
2353 SET_PSR_F (tmp & (1 << a));
2354 trace_output_32 (sd, addr);
2355 }
2356
2357 /* tbitw. */
2358 void
2359 OP_79_8 (SIM_DESC sd, SIM_CPU *cpu)
2360 {
2361 uint16 a = (OP[0]);
2362 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2363 trace_input ("tbitw", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
2364 tmp = RW (addr);
2365 SET_PSR_F (tmp & (1 << a));
2366 trace_output_32 (sd, addr);
2367 }
2368
2369 /* tbitw. */
2370 void
2371 OP_11D_14 (SIM_DESC sd, SIM_CPU *cpu)
2372 {
2373 uint16 a = (OP[0]);
2374 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2375 trace_input ("tbitw", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
2376 tmp = RW (addr);
2377 SET_PSR_F (tmp & (1 << a));
2378 trace_output_32 (sd, addr);
2379 }
2380
2381
2382 /* tbitw. */
2383 void
2384 OP_11E_14 (SIM_DESC sd, SIM_CPU *cpu)
2385 {
2386 uint16 a = (OP[0]);
2387 uint32 addr = (GPR32 (OP[2])) + OP[1], tmp;
2388 trace_input ("tbitw", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
2389 tmp = RW (addr);
2390 SET_PSR_F (tmp & (1 << a));
2391 trace_output_32 (sd, addr);
2392 }
2393
2394
2395 /* tbit. */
2396 void
2397 OP_6_8 (SIM_DESC sd, SIM_CPU *cpu)
2398 {
2399 uint16 a = OP[0];
2400 uint16 b = (GPR (OP[1]));
2401 trace_input ("tbit", OP_CONSTANT4, OP_REG, OP_VOID);
2402 SET_PSR_F (b & (1 << a));
2403 trace_output_16 (sd, b);
2404 }
2405
2406 /* tbit. */
2407 void
2408 OP_7_8 (SIM_DESC sd, SIM_CPU *cpu)
2409 {
2410 uint16 a = GPR (OP[0]);
2411 uint16 b = (GPR (OP[1]));
2412 trace_input ("tbit", OP_REG, OP_REG, OP_VOID);
2413 SET_PSR_F (b & (1 << a));
2414 trace_output_16 (sd, b);
2415 }
2416
2417
2418 /* cmpb. */
2419 void
2420 OP_50_8 (SIM_DESC sd, SIM_CPU *cpu)
2421 {
2422 uint8 a = (OP[0]) & 0xFF;
2423 uint8 b = (GPR (OP[1])) & 0xFF;
2424 trace_input ("cmpb", OP_CONSTANT4, OP_REG, OP_VOID);
2425 SET_PSR_Z (a == b);
2426 SET_PSR_N ((int8)a > (int8)b);
2427 SET_PSR_L (a > b);
2428 trace_output_flag (sd);
2429 }
2430
2431 /* cmpb. */
2432 void
2433 OP_50B_C (SIM_DESC sd, SIM_CPU *cpu)
2434 {
2435 uint8 a = (OP[0]) & 0xFF;
2436 uint8 b = (GPR (OP[1])) & 0xFF;
2437 trace_input ("cmpb", OP_CONSTANT16, OP_REG, OP_VOID);
2438 SET_PSR_Z (a == b);
2439 SET_PSR_N ((int8)a > (int8)b);
2440 SET_PSR_L (a > b);
2441 trace_output_flag (sd);
2442 }
2443
2444 /* cmpb. */
2445 void
2446 OP_51_8 (SIM_DESC sd, SIM_CPU *cpu)
2447 {
2448 uint8 a = (GPR (OP[0])) & 0xFF;
2449 uint8 b = (GPR (OP[1])) & 0xFF;
2450 trace_input ("cmpb", OP_REG, OP_REG, OP_VOID);
2451 SET_PSR_Z (a == b);
2452 SET_PSR_N ((int8)a > (int8)b);
2453 SET_PSR_L (a > b);
2454 trace_output_flag (sd);
2455 }
2456
2457 /* cmpw. */
2458 void
2459 OP_52_8 (SIM_DESC sd, SIM_CPU *cpu)
2460 {
2461 uint16 a = (OP[0]);
2462 uint16 b = GPR (OP[1]);
2463 trace_input ("cmpw", OP_CONSTANT4, OP_REG, OP_VOID);
2464 SET_PSR_Z (a == b);
2465 SET_PSR_N ((int16)a > (int16)b);
2466 SET_PSR_L (a > b);
2467 trace_output_flag (sd);
2468 }
2469
2470 /* cmpw. */
2471 void
2472 OP_52B_C (SIM_DESC sd, SIM_CPU *cpu)
2473 {
2474 uint16 a = (OP[0]);
2475 uint16 b = GPR (OP[1]);
2476 trace_input ("cmpw", OP_CONSTANT16, OP_REG, OP_VOID);
2477 SET_PSR_Z (a == b);
2478 SET_PSR_N ((int16)a > (int16)b);
2479 SET_PSR_L (a > b);
2480 trace_output_flag (sd);
2481 }
2482
2483 /* cmpw. */
2484 void
2485 OP_53_8 (SIM_DESC sd, SIM_CPU *cpu)
2486 {
2487 uint16 a = GPR (OP[0]) ;
2488 uint16 b = GPR (OP[1]) ;
2489 trace_input ("cmpw", OP_REG, OP_REG, OP_VOID);
2490 SET_PSR_Z (a == b);
2491 SET_PSR_N ((int16)a > (int16)b);
2492 SET_PSR_L (a > b);
2493 trace_output_flag (sd);
2494 }
2495
2496 /* cmpd. */
2497 void
2498 OP_56_8 (SIM_DESC sd, SIM_CPU *cpu)
2499 {
2500 uint32 a = (OP[0]);
2501 uint32 b = GPR32 (OP[1]);
2502 trace_input ("cmpd", OP_CONSTANT4, OP_REGP, OP_VOID);
2503 SET_PSR_Z (a == b);
2504 SET_PSR_N ((int32)a > (int32)b);
2505 SET_PSR_L (a > b);
2506 trace_output_flag (sd);
2507 }
2508
2509 /* cmpd. */
2510 void
2511 OP_56B_C (SIM_DESC sd, SIM_CPU *cpu)
2512 {
2513 uint32 a = (SEXT16(OP[0]));
2514 uint32 b = GPR32 (OP[1]);
2515 trace_input ("cmpd", OP_CONSTANT16, OP_REGP, OP_VOID);
2516 SET_PSR_Z (a == b);
2517 SET_PSR_N ((int32)a > (int32)b);
2518 SET_PSR_L (a > b);
2519 trace_output_flag (sd);
2520 }
2521
2522 /* cmpd. */
2523 void
2524 OP_57_8 (SIM_DESC sd, SIM_CPU *cpu)
2525 {
2526 uint32 a = GPR32 (OP[0]) ;
2527 uint32 b = GPR32 (OP[1]) ;
2528 trace_input ("cmpd", OP_REGP, OP_REGP, OP_VOID);
2529 SET_PSR_Z (a == b);
2530 SET_PSR_N ((int32)a > (int32)b);
2531 SET_PSR_L (a > b);
2532 trace_output_flag (sd);
2533 }
2534
2535 /* cmpd. */
2536 void
2537 OP_9_C (SIM_DESC sd, SIM_CPU *cpu)
2538 {
2539 uint32 a = (OP[0]);
2540 uint32 b = GPR32 (OP[1]);
2541 trace_input ("cmpd", OP_CONSTANT32, OP_REGP, OP_VOID);
2542 SET_PSR_Z (a == b);
2543 SET_PSR_N ((int32)a > (int32)b);
2544 SET_PSR_L (a > b);
2545 trace_output_flag (sd);
2546 }
2547
2548
2549 /* movb. */
2550 void
2551 OP_58_8 (SIM_DESC sd, SIM_CPU *cpu)
2552 {
2553 uint8 tmp = OP[0] & 0xFF;
2554 uint16 a = (GPR (OP[1])) & 0xFF00;
2555 trace_input ("movb", OP_CONSTANT4, OP_REG, OP_VOID);
2556 SET_GPR (OP[1], (a | tmp));
2557 trace_output_16 (sd, tmp);
2558 }
2559
2560 /* movb. */
2561 void
2562 OP_58B_C (SIM_DESC sd, SIM_CPU *cpu)
2563 {
2564 uint8 tmp = OP[0] & 0xFF;
2565 uint16 a = (GPR (OP[1])) & 0xFF00;
2566 trace_input ("movb", OP_CONSTANT16, OP_REG, OP_VOID);
2567 SET_GPR (OP[1], (a | tmp));
2568 trace_output_16 (sd, tmp);
2569 }
2570
2571 /* movb. */
2572 void
2573 OP_59_8 (SIM_DESC sd, SIM_CPU *cpu)
2574 {
2575 uint8 tmp = (GPR (OP[0])) & 0xFF;
2576 uint16 a = (GPR (OP[1])) & 0xFF00;
2577 trace_input ("movb", OP_REG, OP_REG, OP_VOID);
2578 SET_GPR (OP[1], (a | tmp));
2579 trace_output_16 (sd, tmp);
2580 }
2581
2582 /* movw. */
2583 void
2584 OP_5A_8 (SIM_DESC sd, SIM_CPU *cpu)
2585 {
2586 uint16 tmp = OP[0];
2587 trace_input ("movw", OP_CONSTANT4_1, OP_REG, OP_VOID);
2588 SET_GPR (OP[1], (tmp & 0xffff));
2589 trace_output_16 (sd, tmp);
2590 }
2591
2592 /* movw. */
2593 void
2594 OP_5AB_C (SIM_DESC sd, SIM_CPU *cpu)
2595 {
2596 int16 tmp = OP[0];
2597 trace_input ("movw", OP_CONSTANT16, OP_REG, OP_VOID);
2598 SET_GPR (OP[1], (tmp & 0xffff));
2599 trace_output_16 (sd, tmp);
2600 }
2601
2602 /* movw. */
2603 void
2604 OP_5B_8 (SIM_DESC sd, SIM_CPU *cpu)
2605 {
2606 uint16 tmp = GPR (OP[0]);
2607 uint32 a = GPR32 (OP[1]);
2608 trace_input ("movw", OP_REG, OP_REGP, OP_VOID);
2609 a = (a & 0xffff0000) | tmp;
2610 SET_GPR32 (OP[1], a);
2611 trace_output_16 (sd, tmp);
2612 }
2613
2614 /* movxb. */
2615 void
2616 OP_5C_8 (SIM_DESC sd, SIM_CPU *cpu)
2617 {
2618 uint8 tmp = (GPR (OP[0])) & 0xFF;
2619 trace_input ("movxb", OP_REG, OP_REG, OP_VOID);
2620 SET_GPR (OP[1], ((SEXT8(tmp)) & 0xffff));
2621 trace_output_16 (sd, tmp);
2622 }
2623
2624 /* movzb. */
2625 void
2626 OP_5D_8 (SIM_DESC sd, SIM_CPU *cpu)
2627 {
2628 uint8 tmp = (GPR (OP[0])) & 0xFF;
2629 trace_input ("movzb", OP_REG, OP_REG, OP_VOID);
2630 SET_GPR (OP[1], tmp);
2631 trace_output_16 (sd, tmp);
2632 }
2633
2634 /* movxw. */
2635 void
2636 OP_5E_8 (SIM_DESC sd, SIM_CPU *cpu)
2637 {
2638 uint16 tmp = GPR (OP[0]);
2639 trace_input ("movxw", OP_REG, OP_REGP, OP_VOID);
2640 SET_GPR32 (OP[1], SEXT16(tmp));
2641 trace_output_16 (sd, tmp);
2642 }
2643
2644 /* movzw. */
2645 void
2646 OP_5F_8 (SIM_DESC sd, SIM_CPU *cpu)
2647 {
2648 uint16 tmp = GPR (OP[0]);
2649 trace_input ("movzw", OP_REG, OP_REGP, OP_VOID);
2650 SET_GPR32 (OP[1], (tmp & 0x0000FFFF));
2651 trace_output_16 (sd, tmp);
2652 }
2653
2654 /* movd. */
2655 void
2656 OP_54_8 (SIM_DESC sd, SIM_CPU *cpu)
2657 {
2658 int32 tmp = OP[0];
2659 trace_input ("movd", OP_CONSTANT4, OP_REGP, OP_VOID);
2660 SET_GPR32 (OP[1], tmp);
2661 trace_output_32 (sd, tmp);
2662 }
2663
2664 /* movd. */
2665 void
2666 OP_54B_C (SIM_DESC sd, SIM_CPU *cpu)
2667 {
2668 int32 tmp = SEXT16(OP[0]);
2669 trace_input ("movd", OP_CONSTANT16, OP_REGP, OP_VOID);
2670 SET_GPR32 (OP[1], tmp);
2671 trace_output_32 (sd, tmp);
2672 }
2673
2674 /* movd. */
2675 void
2676 OP_55_8 (SIM_DESC sd, SIM_CPU *cpu)
2677 {
2678 uint32 tmp = GPR32 (OP[0]);
2679 trace_input ("movd", OP_REGP, OP_REGP, OP_VOID);
2680 SET_GPR32 (OP[1], tmp);
2681 trace_output_32 (sd, tmp);
2682 }
2683
2684 /* movd. */
2685 void
2686 OP_5_8 (SIM_DESC sd, SIM_CPU *cpu)
2687 {
2688 uint32 tmp = OP[0];
2689 trace_input ("movd", OP_CONSTANT20, OP_REGP, OP_VOID);
2690 SET_GPR32 (OP[1], tmp);
2691 trace_output_32 (sd, tmp);
2692 }
2693
2694 /* movd. */
2695 void
2696 OP_7_C (SIM_DESC sd, SIM_CPU *cpu)
2697 {
2698 int32 tmp = OP[0];
2699 trace_input ("movd", OP_CONSTANT32, OP_REGP, OP_VOID);
2700 SET_GPR32 (OP[1], tmp);
2701 trace_output_32 (sd, tmp);
2702 }
2703
2704 /* loadm. */
2705 void
2706 OP_14_D (SIM_DESC sd, SIM_CPU *cpu)
2707 {
2708 uint32 addr = GPR (0);
2709 uint16 count = OP[0], reg = 2, tmp;
2710 trace_input ("loadm", OP_CONSTANT4, OP_VOID, OP_VOID);
2711 if ((addr & 1))
2712 {
2713 trace_output_void (sd);
2714 EXCEPTION (SIM_SIGBUS);
2715 }
2716
2717 while (count)
2718 {
2719 tmp = RW (addr);
2720 SET_GPR (reg, tmp);
2721 addr +=2;
2722 --count;
2723 reg++;
2724 if (reg == 6) reg = 8;
2725 };
2726
2727 SET_GPR (0, addr);
2728 trace_output_void (sd);
2729 }
2730
2731
2732 /* loadmp. */
2733 void
2734 OP_15_D (SIM_DESC sd, SIM_CPU *cpu)
2735 {
2736 uint32 addr = GPR32 (0);
2737 uint16 count = OP[0], reg = 2, tmp;
2738 trace_input ("loadm", OP_CONSTANT4, OP_VOID, OP_VOID);
2739 if ((addr & 1))
2740 {
2741 trace_output_void (sd);
2742 EXCEPTION (SIM_SIGBUS);
2743 }
2744
2745 while (count)
2746 {
2747 tmp = RW (addr);
2748 SET_GPR (reg, tmp);
2749 addr +=2;
2750 --count;
2751 reg++;
2752 if (reg == 6) reg = 8;
2753 };
2754
2755 SET_GPR32 (0, addr);
2756 trace_output_void (sd);
2757 }
2758
2759
2760 /* loadb. */
2761 void
2762 OP_88_8 (SIM_DESC sd, SIM_CPU *cpu)
2763 {
2764 /* loadb ABS20, REG
2765 * ADDR = zext24(abs20) | remap (ie 0xF00000)
2766 * REG = [ADDR]
2767 * NOTE: remap is
2768 * If (abs20 > 0xEFFFF) the resulting address is logically ORed
2769 * with 0xF00000 i.e. addresses from 1M-64k to 1M are re-mapped
2770 * by the core to 16M-64k to 16M. */
2771
2772 uint16 tmp, a = (GPR (OP[1])) & 0xFF00;
2773 uint32 addr = OP[0];
2774 trace_input ("loadb", OP_ABS20, OP_REG, OP_VOID);
2775 if (addr > 0xEFFFF) addr |= 0xF00000;
2776 tmp = (RB (addr));
2777 SET_GPR (OP[1], (a | tmp));
2778 trace_output_16 (sd, tmp);
2779 }
2780
2781 /* loadb. */
2782 void
2783 OP_127_14 (SIM_DESC sd, SIM_CPU *cpu)
2784 {
2785 /* loadb ABS24, REG
2786 * ADDR = abs24
2787 * REGR = [ADDR]. */
2788
2789 uint16 tmp, a = (GPR (OP[1])) & 0xFF00;
2790 uint32 addr = OP[0];
2791 trace_input ("loadb", OP_ABS24, OP_REG, OP_VOID);
2792 tmp = (RB (addr));
2793 SET_GPR (OP[1], (a | tmp));
2794 trace_output_16 (sd, tmp);
2795 }
2796
2797 /* loadb. */
2798 void
2799 OP_45_7 (SIM_DESC sd, SIM_CPU *cpu)
2800 {
2801 /* loadb [Rindex]ABS20 REG
2802 * ADDR = Rindex + zext24(disp20)
2803 * REGR = [ADDR]. */
2804
2805 uint32 addr;
2806 uint16 tmp, a = (GPR (OP[2])) & 0xFF00;
2807 trace_input ("loadb", OP_R_INDEX8_ABS20, OP_REG, OP_VOID);
2808
2809 if (OP[0] == 0)
2810 addr = (GPR32 (12)) + OP[1];
2811 else
2812 addr = (GPR32 (13)) + OP[1];
2813
2814 tmp = (RB (addr));
2815 SET_GPR (OP[2], (a | tmp));
2816 trace_output_16 (sd, tmp);
2817 }
2818
2819
2820 /* loadb. */
2821 void
2822 OP_B_4 (SIM_DESC sd, SIM_CPU *cpu)
2823 {
2824 /* loadb DIPS4(REGP) REG
2825 * ADDR = RPBASE + zext24(DISP4)
2826 * REG = [ADDR]. */
2827 uint16 tmp, a = (GPR (OP[2])) & 0xFF00;
2828 uint32 addr = (GPR32 (OP[1])) + OP[0];
2829 trace_input ("loadb", OP_RP_BASE_DISP4, OP_REG, OP_VOID);
2830 tmp = (RB (addr));
2831 SET_GPR (OP[2], (a | tmp));
2832 trace_output_16 (sd, tmp);
2833 }
2834
2835 /* loadb. */
2836 void
2837 OP_BE_8 (SIM_DESC sd, SIM_CPU *cpu)
2838 {
2839 /* loadb [Rindex]disp0(RPbasex) REG
2840 * ADDR = Rpbasex + Rindex
2841 * REGR = [ADDR] */
2842
2843 uint32 addr;
2844 uint16 tmp, a = (GPR (OP[3])) & 0xFF00;
2845 trace_input ("loadb", OP_RP_INDEX_DISP0, OP_REG, OP_VOID);
2846
2847 addr = (GPR32 (OP[2])) + OP[1];
2848
2849 if (OP[0] == 0)
2850 addr = (GPR32 (12)) + addr;
2851 else
2852 addr = (GPR32 (13)) + addr;
2853
2854 tmp = (RB (addr));
2855 SET_GPR (OP[3], (a | tmp));
2856 trace_output_16 (sd, tmp);
2857 }
2858
2859 /* loadb. */
2860 void
2861 OP_219_A (SIM_DESC sd, SIM_CPU *cpu)
2862 {
2863 /* loadb [Rindex]disp14(RPbasex) REG
2864 * ADDR = Rpbasex + Rindex + zext24(disp14)
2865 * REGR = [ADDR] */
2866
2867 uint32 addr;
2868 uint16 tmp, a = (GPR (OP[3])) & 0xFF00;
2869
2870 addr = (GPR32 (OP[2])) + OP[1];
2871
2872 if (OP[0] == 0)
2873 addr = (GPR32 (12)) + addr;
2874 else
2875 addr = (GPR32 (13)) + addr;
2876
2877 trace_input ("loadb", OP_RP_INDEX_DISP14, OP_REG, OP_VOID);
2878 tmp = (RB (addr));
2879 SET_GPR (OP[3], (a | tmp));
2880 trace_output_16 (sd, tmp);
2881 }
2882
2883
2884 /* loadb. */
2885 void
2886 OP_184_14 (SIM_DESC sd, SIM_CPU *cpu)
2887 {
2888 /* loadb DISPE20(REG) REG
2889 * zext24(Rbase) + zext24(dispe20)
2890 * REG = [ADDR] */
2891
2892 uint16 tmp,a = (GPR (OP[2])) & 0xFF00;
2893 uint32 addr = OP[0] + (GPR (OP[1]));
2894 trace_input ("loadb", OP_R_BASE_DISPE20, OP_REG, OP_VOID);
2895 tmp = (RB (addr));
2896 SET_GPR (OP[2], (a | tmp));
2897 trace_output_16 (sd, tmp);
2898 }
2899
2900 /* loadb. */
2901 void
2902 OP_124_14 (SIM_DESC sd, SIM_CPU *cpu)
2903 {
2904 /* loadb DISP20(REG) REG
2905 * ADDR = zext24(Rbase) + zext24(disp20)
2906 * REG = [ADDR] */
2907
2908 uint16 tmp,a = (GPR (OP[2])) & 0xFF00;
2909 uint32 addr = OP[0] + (GPR (OP[1]));
2910 trace_input ("loadb", OP_R_BASE_DISP20, OP_REG, OP_VOID);
2911 tmp = (RB (addr));
2912 SET_GPR (OP[2], (a | tmp));
2913 trace_output_16 (sd, tmp);
2914 }
2915
2916 /* loadb. */
2917 void
2918 OP_BF_8 (SIM_DESC sd, SIM_CPU *cpu)
2919 {
2920 /* loadb disp16(REGP) REG
2921 * ADDR = RPbase + zext24(disp16)
2922 * REGR = [ADDR] */
2923
2924 uint16 tmp,a = (GPR (OP[2])) & 0xFF00;
2925 uint32 addr = (GPR32 (OP[1])) + OP[0];
2926 trace_input ("loadb", OP_RP_BASE_DISP16, OP_REG, OP_VOID);
2927 tmp = (RB (addr));
2928 SET_GPR (OP[2], (a | tmp));
2929 trace_output_16 (sd, tmp);
2930 }
2931
2932 /* loadb. */
2933 void
2934 OP_125_14 (SIM_DESC sd, SIM_CPU *cpu)
2935 {
2936 /* loadb disp20(REGP) REG
2937 * ADDR = RPbase + zext24(disp20)
2938 * REGR = [ADDR] */
2939 uint16 tmp,a = (GPR (OP[2])) & 0xFF00;
2940 uint32 addr = (GPR32 (OP[1])) + OP[0];
2941 trace_input ("loadb", OP_RP_BASE_DISP20, OP_REG, OP_VOID);
2942 tmp = (RB (addr));
2943 SET_GPR (OP[2], (a | tmp));
2944 trace_output_16 (sd, tmp);
2945 }
2946
2947
2948 /* loadb. */
2949 void
2950 OP_185_14 (SIM_DESC sd, SIM_CPU *cpu)
2951 {
2952 /* loadb -disp20(REGP) REG
2953 * ADDR = RPbase + zext24(-disp20)
2954 * REGR = [ADDR] */
2955 uint16 tmp,a = (GPR (OP[2])) & 0xFF00;
2956 uint32 addr = (GPR32 (OP[1])) + OP[1];
2957 trace_input ("loadb", OP_RP_BASE_DISPE20, OP_REG, OP_VOID);
2958 tmp = (RB (addr));
2959 SET_GPR (OP[2], (a | tmp));
2960 trace_output_16 (sd, tmp);
2961 }
2962
2963 /* loadb. */
2964 void
2965 OP_126_14 (SIM_DESC sd, SIM_CPU *cpu)
2966 {
2967 /* loadb [Rindex]disp20(RPbasexb) REG
2968 * ADDR = RPbasex + Rindex + zext24(disp20)
2969 * REGR = [ADDR] */
2970
2971 uint32 addr;
2972 uint16 tmp, a = (GPR (OP[3])) & 0xFF00;
2973 trace_input ("loadb", OP_RP_INDEX_DISP20, OP_REG, OP_VOID);
2974
2975 addr = (GPR32 (OP[2])) + OP[1];
2976
2977 if (OP[0] == 0)
2978 addr = (GPR32 (12)) + addr;
2979 else
2980 addr = (GPR32 (13)) + addr;
2981
2982 tmp = (RB (addr));
2983 SET_GPR (OP[3], (a | tmp));
2984 trace_output_16 (sd, tmp);
2985 }
2986
2987
2988 /* loadw. */
2989 void
2990 OP_89_8 (SIM_DESC sd, SIM_CPU *cpu)
2991 {
2992 /* loadw ABS20, REG
2993 * ADDR = zext24(abs20) | remap
2994 * REGR = [ADDR]
2995 * NOTE: remap is
2996 * If (abs20 > 0xEFFFF) the resulting address is logically ORed
2997 * with 0xF00000 i.e. addresses from 1M-64k to 1M are re-mapped
2998 * by the core to 16M-64k to 16M. */
2999
3000 uint16 tmp;
3001 uint32 addr = OP[0];
3002 trace_input ("loadw", OP_ABS20, OP_REG, OP_VOID);
3003 if (addr > 0xEFFFF) addr |= 0xF00000;
3004 tmp = (RW (addr));
3005 SET_GPR (OP[1], tmp);
3006 trace_output_16 (sd, tmp);
3007 }
3008
3009
3010 /* loadw. */
3011 void
3012 OP_12F_14 (SIM_DESC sd, SIM_CPU *cpu)
3013 {
3014 /* loadw ABS24, REG
3015 * ADDR = abs24
3016 * REGR = [ADDR] */
3017 uint16 tmp;
3018 uint32 addr = OP[0];
3019 trace_input ("loadw", OP_ABS24, OP_REG, OP_VOID);
3020 tmp = (RW (addr));
3021 SET_GPR (OP[1], tmp);
3022 trace_output_16 (sd, tmp);
3023 }
3024
3025 /* loadw. */
3026 void
3027 OP_47_7 (SIM_DESC sd, SIM_CPU *cpu)
3028 {
3029 /* loadw [Rindex]ABS20 REG
3030 * ADDR = Rindex + zext24(disp20)
3031 * REGR = [ADDR] */
3032
3033 uint32 addr;
3034 uint16 tmp;
3035 trace_input ("loadw", OP_R_INDEX8_ABS20, OP_REG, OP_VOID);
3036
3037 if (OP[0] == 0)
3038 addr = (GPR32 (12)) + OP[1];
3039 else
3040 addr = (GPR32 (13)) + OP[1];
3041
3042 tmp = (RW (addr));
3043 SET_GPR (OP[2], tmp);
3044 trace_output_16 (sd, tmp);
3045 }
3046
3047
3048 /* loadw. */
3049 void
3050 OP_9_4 (SIM_DESC sd, SIM_CPU *cpu)
3051 {
3052 /* loadw DIPS4(REGP) REGP
3053 * ADDR = RPBASE + zext24(DISP4)
3054 * REGP = [ADDR]. */
3055 uint16 tmp;
3056 uint32 addr, a;
3057 trace_input ("loadw", OP_RP_BASE_DISP4, OP_REG, OP_VOID);
3058 addr = (GPR32 (OP[1])) + OP[0];
3059 tmp = (RW (addr));
3060 if (OP[2] > 11)
3061 {
3062 a = (GPR32 (OP[2])) & 0xffff0000;
3063 SET_GPR32 (OP[2], (a | tmp));
3064 }
3065 else
3066 SET_GPR (OP[2], tmp);
3067
3068 trace_output_16 (sd, tmp);
3069 }
3070
3071
3072 /* loadw. */
3073 void
3074 OP_9E_8 (SIM_DESC sd, SIM_CPU *cpu)
3075 {
3076 /* loadw [Rindex]disp0(RPbasex) REG
3077 * ADDR = Rpbasex + Rindex
3078 * REGR = [ADDR] */
3079
3080 uint32 addr;
3081 uint16 tmp;
3082 trace_input ("loadw", OP_RP_INDEX_DISP0, OP_REG, OP_VOID);
3083
3084 addr = (GPR32 (OP[2])) + OP[1];
3085
3086 if (OP[0] == 0)
3087 addr = (GPR32 (12)) + addr;
3088 else
3089 addr = (GPR32 (13)) + addr;
3090
3091 tmp = RW (addr);
3092 SET_GPR (OP[3], tmp);
3093 trace_output_16 (sd, tmp);
3094 }
3095
3096
3097 /* loadw. */
3098 void
3099 OP_21B_A (SIM_DESC sd, SIM_CPU *cpu)
3100 {
3101 /* loadw [Rindex]disp14(RPbasex) REG
3102 * ADDR = Rpbasex + Rindex + zext24(disp14)
3103 * REGR = [ADDR] */
3104
3105 uint32 addr;
3106 uint16 tmp;
3107 trace_input ("loadw", OP_RP_INDEX_DISP14, OP_REG, OP_VOID);
3108 addr = (GPR32 (OP[2])) + OP[1];
3109
3110 if (OP[0] == 0)
3111 addr = (GPR32 (12)) + addr;
3112 else
3113 addr = (GPR32 (13)) + addr;
3114
3115 tmp = (RW (addr));
3116 SET_GPR (OP[3], tmp);
3117 trace_output_16 (sd, tmp);
3118 }
3119
3120 /* loadw. */
3121 void
3122 OP_18C_14 (SIM_DESC sd, SIM_CPU *cpu)
3123 {
3124 /* loadw dispe20(REG) REGP
3125 * REGP = [DISPE20+[REG]] */
3126
3127 uint16 tmp;
3128 uint32 addr, a;
3129 trace_input ("loadw", OP_R_BASE_DISPE20, OP_REGP, OP_VOID);
3130 addr = OP[0] + (GPR (OP[1]));
3131 tmp = (RW (addr));
3132 if (OP[2] > 11)
3133 {
3134 a = (GPR32 (OP[2])) & 0xffff0000;
3135 SET_GPR32 (OP[2], (a | tmp));
3136 }
3137 else
3138 SET_GPR (OP[2], tmp);
3139
3140 trace_output_16 (sd, tmp);
3141 }
3142
3143
3144 /* loadw. */
3145 void
3146 OP_12C_14 (SIM_DESC sd, SIM_CPU *cpu)
3147 {
3148 /* loadw DISP20(REG) REGP
3149 * ADDR = zext24(Rbase) + zext24(disp20)
3150 * REGP = [ADDR] */
3151
3152 uint16 tmp;
3153 uint32 addr, a;
3154 trace_input ("loadw", OP_R_BASE_DISP20, OP_REGP, OP_VOID);
3155 addr = OP[0] + (GPR (OP[1]));
3156 tmp = (RW (addr));
3157 if (OP[2] > 11)
3158 {
3159 a = (GPR32 (OP[2])) & 0xffff0000;
3160 SET_GPR32 (OP[2], (a | tmp));
3161 }
3162 else
3163 SET_GPR (OP[2], tmp);
3164
3165 trace_output_16 (sd, tmp);
3166 }
3167
3168 /* loadw. */
3169 void
3170 OP_9F_8 (SIM_DESC sd, SIM_CPU *cpu)
3171 {
3172 /* loadw disp16(REGP) REGP
3173 * ADDR = RPbase + zext24(disp16)
3174 * REGP = [ADDR] */
3175 uint16 tmp;
3176 uint32 addr, a;
3177 trace_input ("loadw", OP_RP_BASE_DISP16, OP_REGP, OP_VOID);
3178 addr = (GPR32 (OP[1])) + OP[0];
3179 tmp = (RW (addr));
3180 if (OP[2] > 11)
3181 {
3182 a = (GPR32 (OP[2])) & 0xffff0000;
3183 SET_GPR32 (OP[2], (a | tmp));
3184 }
3185 else
3186 SET_GPR (OP[2], tmp);
3187
3188 trace_output_16 (sd, tmp);
3189 }
3190
3191 /* loadw. */
3192 void
3193 OP_12D_14 (SIM_DESC sd, SIM_CPU *cpu)
3194 {
3195 /* loadw disp20(REGP) REGP
3196 * ADDR = RPbase + zext24(disp20)
3197 * REGP = [ADDR] */
3198 uint16 tmp;
3199 uint32 addr, a;
3200 trace_input ("loadw", OP_RP_BASE_DISP20, OP_REG, OP_VOID);
3201 addr = (GPR32 (OP[1])) + OP[0];
3202 tmp = (RW (addr));
3203 if (OP[2] > 11)
3204 {
3205 a = (GPR32 (OP[2])) & 0xffff0000;
3206 SET_GPR32 (OP[2], (a | tmp));
3207 }
3208 else
3209 SET_GPR (OP[2], tmp);
3210
3211 trace_output_16 (sd, tmp);
3212 }
3213
3214 /* loadw. */
3215 void
3216 OP_18D_14 (SIM_DESC sd, SIM_CPU *cpu)
3217 {
3218 /* loadw -disp20(REGP) REG
3219 * ADDR = RPbase + zext24(-disp20)
3220 * REGR = [ADDR] */
3221
3222 uint16 tmp;
3223 uint32 addr, a;
3224 trace_input ("loadw", OP_RP_BASE_DISPE20, OP_REG, OP_VOID);
3225 addr = (GPR32 (OP[1])) + OP[0];
3226 tmp = (RB (addr));
3227 if (OP[2] > 11)
3228 {
3229 a = (GPR32 (OP[2])) & 0xffff0000;
3230 SET_GPR32 (OP[2], (a | tmp));
3231 }
3232 else
3233 SET_GPR (OP[2], tmp);
3234
3235 trace_output_16 (sd, tmp);
3236 }
3237
3238
3239 /* loadw. */
3240 void
3241 OP_12E_14 (SIM_DESC sd, SIM_CPU *cpu)
3242 {
3243 /* loadw [Rindex]disp20(RPbasexb) REG
3244 * ADDR = RPbasex + Rindex + zext24(disp20)
3245 * REGR = [ADDR] */
3246
3247 uint32 addr;
3248 uint16 tmp;
3249 trace_input ("loadw", OP_RP_INDEX_DISP20, OP_REG, OP_VOID);
3250
3251 if (OP[0] == 0)
3252 addr = (GPR32 (12)) + OP[1] + (GPR32 (OP[2]));
3253 else
3254 addr = (GPR32 (13)) + OP[1] + (GPR32 (OP[2]));
3255
3256 tmp = (RW (addr));
3257 SET_GPR (OP[3], tmp);
3258 trace_output_16 (sd, tmp);
3259 }
3260
3261
3262 /* loadd. */
3263 void
3264 OP_87_8 (SIM_DESC sd, SIM_CPU *cpu)
3265 {
3266 /* loadd ABS20, REGP
3267 * ADDR = zext24(abs20) | remap
3268 * REGP = [ADDR]
3269 * NOTE: remap is
3270 * If (abs20 > 0xEFFFF) the resulting address is logically ORed
3271 * with 0xF00000 i.e. addresses from 1M-64k to 1M are re-mapped
3272 * by the core to 16M-64k to 16M. */
3273
3274 uint32 addr, tmp;
3275 addr = OP[0];
3276 trace_input ("loadd", OP_ABS20, OP_REGP, OP_VOID);
3277 if (addr > 0xEFFFF) addr |= 0xF00000;
3278 tmp = RLW (addr);
3279 tmp = ((tmp << 16) & 0xffff)| ((tmp >> 16) & 0xffff);
3280 SET_GPR32 (OP[1], tmp);
3281 trace_output_32 (sd, tmp);
3282 }
3283
3284 /* loadd. */
3285 void
3286 OP_12B_14 (SIM_DESC sd, SIM_CPU *cpu)
3287 {
3288 /* loadd ABS24, REGP
3289 * ADDR = abs24
3290 * REGP = [ADDR] */
3291
3292 uint32 addr = OP[0];
3293 uint32 tmp;
3294 trace_input ("loadd", OP_ABS24, OP_REGP, OP_VOID);
3295 tmp = RLW (addr);
3296 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3297 SET_GPR32 (OP[1],tmp);
3298 trace_output_32 (sd, tmp);
3299 }
3300
3301
3302 /* loadd. */
3303 void
3304 OP_46_7 (SIM_DESC sd, SIM_CPU *cpu)
3305 {
3306 /* loadd [Rindex]ABS20 REGP
3307 * ADDR = Rindex + zext24(disp20)
3308 * REGP = [ADDR] */
3309
3310 uint32 addr, tmp;
3311 trace_input ("loadd", OP_R_INDEX8_ABS20, OP_REGP, OP_VOID);
3312
3313 if (OP[0] == 0)
3314 addr = (GPR32 (12)) + OP[1];
3315 else
3316 addr = (GPR32 (13)) + OP[1];
3317
3318 tmp = RLW (addr);
3319 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3320 SET_GPR32 (OP[2], tmp);
3321 trace_output_32 (sd, tmp);
3322 }
3323
3324
3325 /* loadd. */
3326 void
3327 OP_A_4 (SIM_DESC sd, SIM_CPU *cpu)
3328 {
3329 /* loadd dips4(regp) REGP
3330 * ADDR = Rpbase + zext24(disp4)
3331 * REGP = [ADDR] */
3332
3333 uint32 tmp, addr = (GPR32 (OP[1])) + OP[0];
3334 trace_input ("loadd", OP_RP_BASE_DISP4, OP_REGP, OP_VOID);
3335 tmp = RLW (addr);
3336 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3337 SET_GPR32 (OP[2], tmp);
3338 trace_output_32 (sd, tmp);
3339 }
3340
3341
3342 /* loadd. */
3343 void
3344 OP_AE_8 (SIM_DESC sd, SIM_CPU *cpu)
3345 {
3346 /* loadd [Rindex]disp0(RPbasex) REGP
3347 * ADDR = Rpbasex + Rindex
3348 * REGP = [ADDR] */
3349
3350 uint32 addr, tmp;
3351 trace_input ("loadd", OP_RP_INDEX_DISP0, OP_REGP, OP_VOID);
3352
3353 if (OP[0] == 0)
3354 addr = (GPR32 (12)) + (GPR32 (OP[2])) + OP[1];
3355 else
3356 addr = (GPR32 (13)) + (GPR32 (OP[2])) + OP[1];
3357
3358 tmp = RLW (addr);
3359 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3360 SET_GPR32 (OP[3], tmp);
3361 trace_output_32 (sd, tmp);
3362 }
3363
3364
3365 /* loadd. */
3366 void
3367 OP_21A_A (SIM_DESC sd, SIM_CPU *cpu)
3368 {
3369 /* loadd [Rindex]disp14(RPbasex) REGP
3370 * ADDR = Rpbasex + Rindex + zext24(disp14)
3371 * REGR = [ADDR] */
3372
3373 uint32 addr, tmp;
3374 trace_input ("loadd", OP_RP_INDEX_DISP14, OP_REGP, OP_VOID);
3375
3376 if (OP[0] == 0)
3377 addr = (GPR32 (12)) + OP[1] + (GPR32 (OP[2]));
3378 else
3379 addr = (GPR32 (13)) + OP[1] + (GPR32 (OP[2]));
3380
3381 tmp = RLW (addr);
3382 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3383 SET_GPR (OP[3],tmp);
3384 trace_output_32 (sd, tmp);
3385 }
3386
3387
3388 /* loadd. */
3389 void
3390 OP_188_14 (SIM_DESC sd, SIM_CPU *cpu)
3391 {
3392 /* loadd dispe20(REG) REG
3393 * zext24(Rbase) + zext24(dispe20)
3394 * REG = [ADDR] */
3395
3396 uint32 tmp, addr = OP[0] + (GPR (OP[1]));
3397 trace_input ("loadd", OP_R_BASE_DISPE20, OP_REGP, OP_VOID);
3398 tmp = RLW (addr);
3399 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3400 SET_GPR32 (OP[2], tmp);
3401 trace_output_32 (sd, tmp);
3402 }
3403
3404
3405 /* loadd. */
3406 void
3407 OP_128_14 (SIM_DESC sd, SIM_CPU *cpu)
3408 {
3409 /* loadd DISP20(REG) REG
3410 * ADDR = zext24(Rbase) + zext24(disp20)
3411 * REG = [ADDR] */
3412
3413 uint32 tmp, addr = OP[0] + (GPR (OP[1]));
3414 trace_input ("loadd", OP_R_BASE_DISP20, OP_REGP, OP_VOID);
3415 tmp = RLW (addr);
3416 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3417 SET_GPR32 (OP[2], tmp);
3418 trace_output_32 (sd, tmp);
3419 }
3420
3421 /* loadd. */
3422 void
3423 OP_AF_8 (SIM_DESC sd, SIM_CPU *cpu)
3424 {
3425 /* loadd disp16(REGP) REGP
3426 * ADDR = RPbase + zext24(disp16)
3427 * REGR = [ADDR] */
3428 uint32 tmp, addr = OP[0] + (GPR32 (OP[1]));
3429 trace_input ("loadd", OP_RP_BASE_DISP16, OP_REGP, OP_VOID);
3430 tmp = RLW (addr);
3431 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3432 SET_GPR32 (OP[2], tmp);
3433 trace_output_32 (sd, tmp);
3434 }
3435
3436
3437 /* loadd. */
3438 void
3439 OP_129_14 (SIM_DESC sd, SIM_CPU *cpu)
3440 {
3441 /* loadd disp20(REGP) REGP
3442 * ADDR = RPbase + zext24(disp20)
3443 * REGP = [ADDR] */
3444 uint32 tmp, addr = OP[0] + (GPR32 (OP[1]));
3445 trace_input ("loadd", OP_RP_BASE_DISP20, OP_REGP, OP_VOID);
3446 tmp = RLW (addr);
3447 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3448 SET_GPR32 (OP[2], tmp);
3449 trace_output_32 (sd, tmp);
3450 }
3451
3452 /* loadd. */
3453 void
3454 OP_189_14 (SIM_DESC sd, SIM_CPU *cpu)
3455 {
3456 /* loadd -disp20(REGP) REGP
3457 * ADDR = RPbase + zext24(-disp20)
3458 * REGP = [ADDR] */
3459
3460 uint32 tmp, addr = OP[0] + (GPR32 (OP[1]));
3461 trace_input ("loadd", OP_RP_BASE_DISPE20, OP_REGP, OP_VOID);
3462 tmp = RLW (addr);
3463 tmp = ((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff);
3464 SET_GPR32 (OP[2], tmp);
3465 trace_output_32 (sd, tmp);
3466 }
3467
3468 /* loadd. */
3469 void
3470 OP_12A_14 (SIM_DESC sd, SIM_CPU *cpu)
3471 {
3472 /* loadd [Rindex]disp20(RPbasexb) REGP
3473 * ADDR = RPbasex + Rindex + zext24(disp20)
3474 * REGP = [ADDR] */
3475
3476 uint32 addr, tmp;
3477 trace_input ("loadd", OP_RP_INDEX_DISP20, OP_REGP, OP_VOID);
3478
3479 if (OP[0] == 0)
3480 addr = (GPR32 (12)) + OP[1] + (GPR32 (OP[2]));
3481 else
3482 addr = (GPR32 (13)) + OP[1] + (GPR32 (OP[2]));
3483
3484 tmp = RLW (addr);
3485 tmp = ((tmp << 16) & 0xffff)| ((tmp >> 16) & 0xffff);
3486 SET_GPR32 (OP[3], tmp);
3487 trace_output_32 (sd, tmp);
3488 }
3489
3490
3491 /* storb. */
3492 void
3493 OP_C8_8 (SIM_DESC sd, SIM_CPU *cpu)
3494 {
3495 /* storb REG, ABS20
3496 * ADDR = zext24(abs20) | remap
3497 * [ADDR] = REGR
3498 * NOTE: remap is
3499 * If (abs20 > 0xEFFFF) the resulting address is logically ORed
3500 * with 0xF00000 i.e. addresses from 1M-64k to 1M are re-mapped
3501 * by the core to 16M-64k to 16M. */
3502
3503 uint8 a = ((GPR (OP[0])) & 0xff);
3504 uint32 addr = OP[1];
3505 trace_input ("storb", OP_REG, OP_ABS20_OUTPUT, OP_VOID);
3506 SB (addr, a);
3507 trace_output_32 (sd, addr);
3508 }
3509
3510 /* storb. */
3511 void
3512 OP_137_14 (SIM_DESC sd, SIM_CPU *cpu)
3513 {
3514 /* storb REG, ABS24
3515 * ADDR = abs24
3516 * [ADDR] = REGR. */
3517
3518 uint8 a = ((GPR (OP[0])) & 0xff);
3519 uint32 addr = OP[1];
3520 trace_input ("storb", OP_REG, OP_ABS24_OUTPUT, OP_VOID);
3521 SB (addr, a);
3522 trace_output_32 (sd, addr);
3523 }
3524
3525 /* storb. */
3526 void
3527 OP_65_7 (SIM_DESC sd, SIM_CPU *cpu)
3528 {
3529 /* storb REG, [Rindex]ABS20
3530 * ADDR = Rindex + zext24(disp20)
3531 * [ADDR] = REGR */
3532
3533 uint32 addr;
3534 uint8 a = ((GPR (OP[0])) & 0xff);
3535 trace_input ("storb", OP_REG, OP_R_INDEX8_ABS20, OP_VOID);
3536
3537 if (OP[1] == 0)
3538 addr = (GPR32 (12)) + OP[2];
3539 else
3540 addr = (GPR32 (13)) + OP[2];
3541
3542 SB (addr, a);
3543 trace_output_32 (sd, addr);
3544 }
3545
3546 /* storb. */
3547 void
3548 OP_F_4 (SIM_DESC sd, SIM_CPU *cpu)
3549 {
3550 /* storb REG, DIPS4(REGP)
3551 * ADDR = RPBASE + zext24(DISP4)
3552 * [ADDR] = REG. */
3553
3554 uint16 a = ((GPR (OP[0])) & 0xff);
3555 uint32 addr = (GPR32 (OP[2])) + OP[1];
3556 trace_input ("storb", OP_REG, OP_RP_BASE_DISPE4, OP_VOID);
3557 SB (addr, a);
3558 trace_output_32 (sd, addr);
3559 }
3560
3561 /* storb. */
3562 void
3563 OP_FE_8 (SIM_DESC sd, SIM_CPU *cpu)
3564 {
3565 /* storb [Rindex]disp0(RPbasex) REG
3566 * ADDR = Rpbasex + Rindex
3567 * [ADDR] = REGR */
3568
3569 uint32 addr;
3570 uint8 a = ((GPR (OP[0])) & 0xff);
3571 trace_input ("storb", OP_REG, OP_RP_INDEX_DISP0, OP_VOID);
3572
3573 if (OP[1] == 0)
3574 addr = (GPR32 (12)) + (GPR32 (OP[3])) + OP[2];
3575 else
3576 addr = (GPR32 (13)) + (GPR32 (OP[3])) + OP[2];
3577
3578 SB (addr, a);
3579 trace_output_32 (sd, addr);
3580 }
3581
3582 /* storb. */
3583 void
3584 OP_319_A (SIM_DESC sd, SIM_CPU *cpu)
3585 {
3586 /* storb REG, [Rindex]disp14(RPbasex)
3587 * ADDR = Rpbasex + Rindex + zext24(disp14)
3588 * [ADDR] = REGR */
3589
3590 uint8 a = ((GPR (OP[0])) & 0xff);
3591 uint32 addr = (GPR32 (OP[2])) + OP[1];
3592 trace_input ("storb", OP_REG, OP_RP_INDEX_DISP14, OP_VOID);
3593 SB (addr, a);
3594 trace_output_32 (sd, addr);
3595 }
3596
3597 /* storb. */
3598 void
3599 OP_194_14 (SIM_DESC sd, SIM_CPU *cpu)
3600 {
3601 /* storb REG, DISPE20(REG)
3602 * zext24(Rbase) + zext24(dispe20)
3603 * [ADDR] = REG */
3604
3605 uint8 a = ((GPR (OP[0])) & 0xff);
3606 uint32 addr = OP[1] + (GPR (OP[2]));
3607 trace_input ("storb", OP_REG, OP_R_BASE_DISPE20, OP_VOID);
3608 SB (addr, a);
3609 trace_output_32 (sd, addr);
3610 }
3611
3612 /* storb. */
3613 void
3614 OP_134_14 (SIM_DESC sd, SIM_CPU *cpu)
3615 {
3616 /* storb REG, DISP20(REG)
3617 * ADDR = zext24(Rbase) + zext24(disp20)
3618 * [ADDR] = REG */
3619
3620 uint8 a = (GPR (OP[0]) & 0xff);
3621 uint32 addr = OP[1] + (GPR (OP[2]));
3622 trace_input ("storb", OP_REG, OP_R_BASE_DISPS20, OP_VOID);
3623 SB (addr, a);
3624 trace_output_32 (sd, addr);
3625 }
3626
3627 /* storb. */
3628 void
3629 OP_FF_8 (SIM_DESC sd, SIM_CPU *cpu)
3630 {
3631 /* storb REG, disp16(REGP)
3632 * ADDR = RPbase + zext24(disp16)
3633 * [ADDR] = REGP */
3634
3635 uint8 a = ((GPR (OP[0])) & 0xff);
3636 uint32 addr = (GPR32 (OP[2])) + OP[1];
3637 trace_input ("storb", OP_REG, OP_RP_BASE_DISP16, OP_VOID);
3638 SB (addr, a);
3639 trace_output_32 (sd, addr);
3640 }
3641
3642 /* storb. */
3643 void
3644 OP_135_14 (SIM_DESC sd, SIM_CPU *cpu)
3645 {
3646 /* storb REG, disp20(REGP)
3647 * ADDR = RPbase + zext24(disp20)
3648 * [ADDR] = REGP */
3649
3650 uint8 a = ((GPR (OP[0])) & 0xff);
3651 uint32 addr = (GPR32 (OP[2])) + OP[1];
3652 trace_input ("storb", OP_REG, OP_RP_BASE_DISPS20, OP_VOID);
3653 SB (addr, a);
3654 trace_output_32 (sd, addr);
3655 }
3656
3657 /* storb. */
3658 void
3659 OP_195_14 (SIM_DESC sd, SIM_CPU *cpu)
3660 {
3661 /* storb REG, -disp20(REGP)
3662 * ADDR = RPbase + zext24(-disp20)
3663 * [ADDR] = REGP */
3664
3665 uint8 a = (GPR (OP[0]) & 0xff);
3666 uint32 addr = (GPR32 (OP[2])) + OP[1];
3667 trace_input ("storb", OP_REG, OP_RP_BASE_DISPE20, OP_VOID);
3668 SB (addr, a);
3669 trace_output_32 (sd, addr);
3670 }
3671
3672 /* storb. */
3673 void
3674 OP_136_14 (SIM_DESC sd, SIM_CPU *cpu)
3675 {
3676 /* storb REG, [Rindex]disp20(RPbase)
3677 * ADDR = RPbasex + Rindex + zext24(disp20)
3678 * [ADDR] = REGP */
3679
3680 uint8 a = (GPR (OP[0])) & 0xff;
3681 uint32 addr = (GPR32 (OP[2])) + OP[1];
3682 trace_input ("storb", OP_REG, OP_RP_INDEX_DISPS20, OP_VOID);
3683 SB (addr, a);
3684 trace_output_32 (sd, addr);
3685 }
3686
3687 /* STR_IMM instructions. */
3688 /* storb . */
3689 void
3690 OP_81_8 (SIM_DESC sd, SIM_CPU *cpu)
3691 {
3692 uint8 a = (OP[0]) & 0xff;
3693 uint32 addr = OP[1];
3694 trace_input ("storb", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
3695 SB (addr, a);
3696 trace_output_32 (sd, addr);
3697 }
3698
3699 /* storb. */
3700 void
3701 OP_123_14 (SIM_DESC sd, SIM_CPU *cpu)
3702 {
3703 uint8 a = (OP[0]) & 0xff;
3704 uint32 addr = OP[1];
3705 trace_input ("storb", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
3706 SB (addr, a);
3707 trace_output_32 (sd, addr);
3708 }
3709
3710 /* storb. */
3711 void
3712 OP_42_7 (SIM_DESC sd, SIM_CPU *cpu)
3713 {
3714 uint32 addr;
3715 uint8 a = (OP[0]) & 0xff;
3716 trace_input ("storb", OP_CONSTANT4, OP_R_INDEX8_ABS20, OP_VOID);
3717
3718 if (OP[1] == 0)
3719 addr = (GPR32 (12)) + OP[2];
3720 else
3721 addr = (GPR32 (13)) + OP[2];
3722
3723 SB (addr, a);
3724 trace_output_32 (sd, addr);
3725 }
3726
3727 /* storb. */
3728 void
3729 OP_218_A (SIM_DESC sd, SIM_CPU *cpu)
3730 {
3731 uint8 a = (OP[0]) & 0xff;
3732 uint32 addr = (GPR32 (OP[2])) + OP[1];
3733 trace_input ("storb", OP_CONSTANT4, OP_RP_BASE_DISP14, OP_VOID);
3734 SB (addr, a);
3735 trace_output_32 (sd, addr);
3736 }
3737
3738 /* storb. */
3739 void
3740 OP_82_8 (SIM_DESC sd, SIM_CPU *cpu)
3741 {
3742 uint8 a = (OP[0]) & 0xff;
3743 uint32 addr = (GPR32 (OP[2])) + OP[1];
3744 trace_input ("storb", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
3745 SB (addr, a);
3746 trace_output_32 (sd, addr);
3747 }
3748
3749 /* storb. */
3750 void
3751 OP_120_14 (SIM_DESC sd, SIM_CPU *cpu)
3752 {
3753 uint8 a = (OP[0]) & 0xff;
3754 uint32 addr = (GPR (OP[2])) + OP[1];
3755 trace_input ("storb", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
3756 SB (addr, a);
3757 trace_output_32 (sd, addr);
3758 }
3759
3760 /* storb. */
3761 void
3762 OP_83_8 (SIM_DESC sd, SIM_CPU *cpu)
3763 {
3764 uint8 a = (OP[0]) & 0xff;
3765 uint32 addr = (GPR32 (OP[2])) + OP[1];
3766 trace_input ("storb", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
3767 SB (addr, a);
3768 trace_output_32 (sd, addr);
3769 }
3770
3771 /* storb. */
3772 void
3773 OP_121_14 (SIM_DESC sd, SIM_CPU *cpu)
3774 {
3775 uint8 a = (OP[0]) & 0xff;
3776 uint32 addr = (GPR32 (OP[2])) + OP[1];
3777 trace_input ("storb", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
3778 SB (addr, a);
3779 trace_output_32 (sd, addr);
3780 }
3781
3782 /* storb. */
3783 void
3784 OP_122_14 (SIM_DESC sd, SIM_CPU *cpu)
3785 {
3786 uint8 a = (OP[0]) & 0xff;
3787 uint32 addr = (GPR32 (OP[2])) + OP[1];
3788 trace_input ("storb", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
3789 SB (addr, a);
3790 trace_output_32 (sd, addr);
3791 }
3792 /* endif for STR_IMM. */
3793
3794 /* storw . */
3795 void
3796 OP_C9_8 (SIM_DESC sd, SIM_CPU *cpu)
3797 {
3798 uint16 a = GPR (OP[0]);
3799 uint32 addr = OP[1];
3800 trace_input ("storw", OP_REG, OP_ABS20_OUTPUT, OP_VOID);
3801 SW (addr, a);
3802 trace_output_32 (sd, addr);
3803 }
3804
3805 /* storw. */
3806 void
3807 OP_13F_14 (SIM_DESC sd, SIM_CPU *cpu)
3808 {
3809 uint16 a = GPR (OP[0]);
3810 uint32 addr = OP[1];
3811 trace_input ("storw", OP_REG, OP_ABS24_OUTPUT, OP_VOID);
3812 SW (addr, a);
3813 trace_output_32 (sd, addr);
3814 }
3815
3816 /* storw. */
3817 void
3818 OP_67_7 (SIM_DESC sd, SIM_CPU *cpu)
3819 {
3820 uint32 addr;
3821 uint16 a = GPR (OP[0]);
3822 trace_input ("storw", OP_REG, OP_R_INDEX8_ABS20, OP_VOID);
3823
3824 if (OP[1] == 0)
3825 addr = (GPR32 (12)) + OP[2];
3826 else
3827 addr = (GPR32 (13)) + OP[2];
3828
3829 SW (addr, a);
3830 trace_output_32 (sd, addr);
3831 }
3832
3833
3834 /* storw. */
3835 void
3836 OP_D_4 (SIM_DESC sd, SIM_CPU *cpu)
3837 {
3838 uint16 a = (GPR (OP[0]));
3839 uint32 addr = (GPR32 (OP[2])) + OP[1];
3840 trace_input ("storw", OP_REGP, OP_RP_BASE_DISPE4, OP_VOID);
3841 SW (addr, a);
3842 trace_output_32 (sd, addr);
3843 }
3844
3845 /* storw. */
3846 void
3847 OP_DE_8 (SIM_DESC sd, SIM_CPU *cpu)
3848 {
3849 uint16 a = GPR (OP[0]);
3850 uint32 addr = (GPR32 (OP[2])) + OP[1];
3851 trace_input ("storw", OP_REG, OP_RP_INDEX_DISP0, OP_VOID);
3852 SW (addr, a);
3853 trace_output_32 (sd, addr);
3854 }
3855
3856 /* storw. */
3857 void
3858 OP_31B_A (SIM_DESC sd, SIM_CPU *cpu)
3859 {
3860 uint16 a = GPR (OP[0]);
3861 uint32 addr = (GPR32 (OP[2])) + OP[1];
3862 trace_input ("storw", OP_REG, OP_RP_INDEX_DISP14, OP_VOID);
3863 SW (addr, a);
3864 trace_output_32 (sd, addr);
3865 }
3866
3867 /* storw. */
3868 void
3869 OP_19C_14 (SIM_DESC sd, SIM_CPU *cpu)
3870 {
3871 uint16 a = (GPR (OP[0]));
3872 uint32 addr = (GPR32 (OP[2])) + OP[1];
3873 trace_input ("storw", OP_REGP, OP_RP_BASE_DISPE20, OP_VOID);
3874 SW (addr, a);
3875 trace_output_32 (sd, addr);
3876 }
3877
3878 /* storw. */
3879 void
3880 OP_13C_14 (SIM_DESC sd, SIM_CPU *cpu)
3881 {
3882 uint16 a = (GPR (OP[0]));
3883 uint32 addr = (GPR (OP[2])) + OP[1];
3884 trace_input ("storw", OP_REG, OP_R_BASE_DISPS20, OP_VOID);
3885 SW (addr, a);
3886 trace_output_32 (sd, addr);
3887 }
3888
3889 /* storw. */
3890 void
3891 OP_DF_8 (SIM_DESC sd, SIM_CPU *cpu)
3892 {
3893 uint16 a = (GPR (OP[0]));
3894 uint32 addr = (GPR32 (OP[2])) + OP[1];
3895 trace_input ("storw", OP_REG, OP_RP_BASE_DISP16, OP_VOID);
3896 SW (addr, a);
3897 trace_output_32 (sd, addr);
3898 }
3899
3900 /* storw. */
3901 void
3902 OP_13D_14 (SIM_DESC sd, SIM_CPU *cpu)
3903 {
3904 uint16 a = (GPR (OP[0]));
3905 uint32 addr = (GPR32 (OP[2])) + OP[1];
3906 trace_input ("storw", OP_REG, OP_RP_BASE_DISPS20, OP_VOID);
3907 SW (addr, a);
3908 trace_output_32 (sd, addr);
3909 }
3910
3911 /* storw. */
3912 void
3913 OP_19D_14 (SIM_DESC sd, SIM_CPU *cpu)
3914 {
3915 uint16 a = (GPR (OP[0]));
3916 uint32 addr = (GPR32 (OP[2])) + OP[1];
3917 trace_input ("storw", OP_REG, OP_RP_BASE_DISPE20, OP_VOID);
3918 SW (addr, a);
3919 trace_output_32 (sd, addr);
3920 }
3921
3922 /* storw. */
3923 void
3924 OP_13E_14 (SIM_DESC sd, SIM_CPU *cpu)
3925 {
3926 uint16 a = (GPR (OP[0]));
3927 uint32 addr = (GPR32 (OP[2])) + OP[1];
3928 trace_input ("storw", OP_REG, OP_RP_INDEX_DISPS20, OP_VOID);
3929 SW (addr, a);
3930 trace_output_32 (sd, addr);
3931 }
3932
3933 /* STORE-w IMM instruction *****/
3934 /* storw . */
3935 void
3936 OP_C1_8 (SIM_DESC sd, SIM_CPU *cpu)
3937 {
3938 uint16 a = OP[0];
3939 uint32 addr = OP[1];
3940 trace_input ("storw", OP_CONSTANT4, OP_ABS20_OUTPUT, OP_VOID);
3941 SW (addr, a);
3942 trace_output_32 (sd, addr);
3943 }
3944
3945 /* storw. */
3946 void
3947 OP_133_14 (SIM_DESC sd, SIM_CPU *cpu)
3948 {
3949 uint16 a = OP[0];
3950 uint32 addr = OP[1];
3951 trace_input ("storw", OP_CONSTANT4, OP_ABS24_OUTPUT, OP_VOID);
3952 SW (addr, a);
3953 trace_output_32 (sd, addr);
3954 }
3955
3956 /* storw. */
3957 void
3958 OP_62_7 (SIM_DESC sd, SIM_CPU *cpu)
3959 {
3960 uint32 addr;
3961 uint16 a = OP[0];
3962 trace_input ("storw", OP_CONSTANT4, OP_R_INDEX8_ABS20, OP_VOID);
3963
3964 if (OP[1] == 0)
3965 addr = (GPR32 (12)) + OP[2];
3966 else
3967 addr = (GPR32 (13)) + OP[2];
3968
3969 SW (addr, a);
3970 trace_output_32 (sd, addr);
3971 }
3972
3973 /* storw. */
3974 void
3975 OP_318_A (SIM_DESC sd, SIM_CPU *cpu)
3976 {
3977 uint16 a = OP[0];
3978 uint32 addr = (GPR32 (OP[2])) + OP[1];
3979 trace_input ("storw", OP_CONSTANT4, OP_RP_BASE_DISP14, OP_VOID);
3980 SW (addr, a);
3981 trace_output_32 (sd, addr);
3982 }
3983
3984 /* storw. */
3985 void
3986 OP_C2_8 (SIM_DESC sd, SIM_CPU *cpu)
3987 {
3988 uint16 a = OP[0];
3989 uint32 addr = (GPR32 (OP[2])) + OP[1];
3990 trace_input ("storw", OP_CONSTANT4, OP_RP_INDEX_DISP0, OP_VOID);
3991 SW (addr, a);
3992 trace_output_32 (sd, addr);
3993 }
3994
3995 /* storw. */
3996 void
3997 OP_130_14 (SIM_DESC sd, SIM_CPU *cpu)
3998 {
3999 uint16 a = OP[0];
4000 uint32 addr = (GPR32 (OP[2])) + OP[1];
4001 trace_input ("storw", OP_CONSTANT4, OP_R_BASE_DISPS20, OP_VOID);
4002 SW (addr, a);
4003 trace_output_32 (sd, addr);
4004 }
4005
4006 /* storw. */
4007 void
4008 OP_C3_8 (SIM_DESC sd, SIM_CPU *cpu)
4009 {
4010 uint16 a = OP[0];
4011 uint32 addr = (GPR32 (OP[2])) + OP[1];
4012 trace_input ("storw", OP_CONSTANT4, OP_RP_BASE_DISP16, OP_VOID);
4013 SW (addr, a);
4014 trace_output_32 (sd, addr);
4015 }
4016
4017
4018 /* storw. */
4019 void
4020 OP_131_14 (SIM_DESC sd, SIM_CPU *cpu)
4021 {
4022 uint16 a = OP[0];
4023 uint32 addr = (GPR32 (OP[2])) + OP[1];
4024 trace_input ("storw", OP_CONSTANT4, OP_RP_BASE_DISPS20, OP_VOID);
4025 SW (addr, a);
4026 trace_output_32 (sd, addr);
4027 }
4028
4029 /* storw. */
4030 void
4031 OP_132_14 (SIM_DESC sd, SIM_CPU *cpu)
4032 {
4033 uint16 a = OP[0];
4034 uint32 addr = (GPR32 (OP[2])) + OP[1];
4035 trace_input ("storw", OP_CONSTANT4, OP_RP_INDEX_DISPS20, OP_VOID);
4036 SW (addr, a);
4037 trace_output_32 (sd, addr);
4038 }
4039
4040
4041 /* stord. */
4042 void
4043 OP_C7_8 (SIM_DESC sd, SIM_CPU *cpu)
4044 {
4045 uint32 a = GPR32 (OP[0]);
4046 uint32 addr = OP[1];
4047 trace_input ("stord", OP_REGP, OP_ABS20_OUTPUT, OP_VOID);
4048 SLW (addr, a);
4049 trace_output_32 (sd, addr);
4050 }
4051
4052 /* stord. */
4053 void
4054 OP_13B_14 (SIM_DESC sd, SIM_CPU *cpu)
4055 {
4056 uint32 a = GPR32 (OP[0]);
4057 uint32 addr = OP[1];
4058 trace_input ("stord", OP_REGP, OP_ABS24_OUTPUT, OP_VOID);
4059 SLW (addr, a);
4060 trace_output_32 (sd, addr);
4061 }
4062
4063 /* stord. */
4064 void
4065 OP_66_7 (SIM_DESC sd, SIM_CPU *cpu)
4066 {
4067 uint32 addr, a = GPR32 (OP[0]);
4068 trace_input ("stord", OP_REGP, OP_R_INDEX8_ABS20, OP_VOID);
4069
4070 if (OP[1] == 0)
4071 addr = (GPR32 (12)) + OP[2];
4072 else
4073 addr = (GPR32 (13)) + OP[2];
4074
4075 SLW (addr, a);
4076 trace_output_32 (sd, addr);
4077 }
4078
4079 /* stord. */
4080 void
4081 OP_E_4 (SIM_DESC sd, SIM_CPU *cpu)
4082 {
4083 uint32 a = GPR32 (OP[0]);
4084 uint32 addr = (GPR32 (OP[2])) + OP[1];
4085 trace_input ("stord", OP_REGP, OP_RP_BASE_DISPE4, OP_VOID);
4086 SLW (addr, a);
4087 trace_output_32 (sd, addr);
4088 }
4089
4090 /* stord. */
4091 void
4092 OP_EE_8 (SIM_DESC sd, SIM_CPU *cpu)
4093 {
4094 uint32 a = GPR32 (OP[0]);
4095 uint32 addr = (GPR32 (OP[2])) + OP[1];
4096 trace_input ("stord", OP_REGP, OP_RP_INDEX_DISP0, OP_VOID);
4097 SLW (addr, a);
4098 trace_output_32 (sd, addr);
4099 }
4100
4101 /* stord. */
4102 void
4103 OP_31A_A (SIM_DESC sd, SIM_CPU *cpu)
4104 {
4105 uint32 a = GPR32 (OP[0]);
4106 uint32 addr = (GPR32 (OP[2])) + OP[1];
4107 trace_input ("stord", OP_REGP, OP_RP_INDEX_DISP14, OP_VOID);
4108 SLW (addr, a);
4109 trace_output_32 (sd, addr);
4110 }
4111
4112 /* stord. */
4113 void
4114 OP_198_14 (SIM_DESC sd, SIM_CPU *cpu)
4115 {
4116 uint32 a = GPR32 (OP[0]);
4117 uint32 addr = (GPR32 (OP[2])) + OP[1];
4118 trace_input ("stord", OP_REGP, OP_R_BASE_DISPE20, OP_VOID);
4119 SLW (addr, a);
4120 trace_output_32 (sd, addr);
4121 }
4122
4123 /* stord. */
4124 void
4125 OP_138_14 (SIM_DESC sd, SIM_CPU *cpu)
4126 {
4127 uint32 a = GPR32 (OP[0]);
4128 uint32 addr = (GPR32 (OP[2])) + OP[1];
4129 trace_input ("stord", OP_REGP, OP_R_BASE_DISPS20, OP_VOID);
4130 SLW (addr, a);
4131 trace_output_32 (sd, addr);
4132 }
4133
4134 /* stord. */
4135 void
4136 OP_EF_8 (SIM_DESC sd, SIM_CPU *cpu)
4137 {
4138 uint32 a = GPR32 (OP[0]);
4139 uint32 addr = (GPR32 (OP[2])) + OP[1];
4140 trace_input ("stord", OP_REGP, OP_RP_BASE_DISP16, OP_VOID);
4141 SLW (addr, a);
4142 trace_output_32 (sd, addr);
4143 }
4144
4145 /* stord. */
4146 void
4147 OP_139_14 (SIM_DESC sd, SIM_CPU *cpu)
4148 {
4149 uint32 a = GPR32 (OP[0]);
4150 uint32 addr = (GPR32 (OP[2])) + OP[1];
4151 trace_input ("stord", OP_REGP, OP_RP_BASE_DISPS20, OP_VOID);
4152 SLW (addr, a);
4153 trace_output_32 (sd, addr);
4154 }
4155
4156 /* stord. */
4157 void
4158 OP_199_14 (SIM_DESC sd, SIM_CPU *cpu)
4159 {
4160 uint32 a = GPR32 (OP[0]);
4161 uint32 addr = (GPR32 (OP[2])) + OP[1];
4162 trace_input ("stord", OP_REGP, OP_RP_BASE_DISPE20, OP_VOID);
4163 SLW (addr, a);
4164 trace_output_32 (sd, addr);
4165 }
4166
4167 /* stord. */
4168 void
4169 OP_13A_14 (SIM_DESC sd, SIM_CPU *cpu)
4170 {
4171 uint32 a = GPR32 (OP[0]);
4172 uint32 addr = (GPR32 (OP[2])) + OP[1];
4173 trace_input ("stord", OP_REGP, OP_RP_INDEX_DISPS20, OP_VOID);
4174 SLW (addr, a);
4175 trace_output_32 (sd, addr);
4176 }
4177
4178 /* macqu. */
4179 void
4180 OP_14D_14 (SIM_DESC sd, SIM_CPU *cpu)
4181 {
4182 int32 tmp;
4183 int16 src1, src2;
4184 trace_input ("macuw", OP_REG, OP_REG, OP_REGP);
4185 src1 = GPR (OP[0]);
4186 src2 = GPR (OP[1]);
4187 tmp = src1 * src2;
4188 /*REVISIT FOR SATURATION and Q FORMAT. */
4189 SET_GPR32 (OP[2], tmp);
4190 trace_output_32 (sd, tmp);
4191 }
4192
4193 /* macuw. */
4194 void
4195 OP_14E_14 (SIM_DESC sd, SIM_CPU *cpu)
4196 {
4197 uint32 tmp;
4198 uint16 src1, src2;
4199 trace_input ("macuw", OP_REG, OP_REG, OP_REGP);
4200 src1 = GPR (OP[0]);
4201 src2 = GPR (OP[1]);
4202 tmp = src1 * src2;
4203 /*REVISIT FOR SATURATION. */
4204 SET_GPR32 (OP[2], tmp);
4205 trace_output_32 (sd, tmp);
4206 }
4207
4208 /* macsw. */
4209 void
4210 OP_14F_14 (SIM_DESC sd, SIM_CPU *cpu)
4211 {
4212 int32 tmp;
4213 int16 src1, src2;
4214 trace_input ("macsw", OP_REG, OP_REG, OP_REGP);
4215 src1 = GPR (OP[0]);
4216 src2 = GPR (OP[1]);
4217 tmp = src1 * src2;
4218 /*REVISIT FOR SATURATION. */
4219 SET_GPR32 (OP[2], tmp);
4220 trace_output_32 (sd, tmp);
4221 }
4222
4223
4224 /* mulb. */
4225 void
4226 OP_64_8 (SIM_DESC sd, SIM_CPU *cpu)
4227 {
4228 int16 tmp;
4229 int8 a = (OP[0]) & 0xff;
4230 int8 b = (GPR (OP[1])) & 0xff;
4231 trace_input ("mulb", OP_CONSTANT4_1, OP_REG, OP_VOID);
4232 tmp = (a * b) & 0xff;
4233 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
4234 trace_output_16 (sd, tmp);
4235 }
4236
4237 /* mulb. */
4238 void
4239 OP_64B_C (SIM_DESC sd, SIM_CPU *cpu)
4240 {
4241 int16 tmp;
4242 int8 a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
4243 trace_input ("mulb", OP_CONSTANT4, OP_REG, OP_VOID);
4244 tmp = (a * b) & 0xff;
4245 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
4246 trace_output_16 (sd, tmp);
4247 }
4248
4249
4250 /* mulb. */
4251 void
4252 OP_65_8 (SIM_DESC sd, SIM_CPU *cpu)
4253 {
4254 int16 tmp;
4255 int8 a = (GPR (OP[0])) & 0xff, b = (GPR (OP[1])) & 0xff;
4256 trace_input ("mulb", OP_REG, OP_REG, OP_VOID);
4257 tmp = (a * b) & 0xff;
4258 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
4259 trace_output_16 (sd, tmp);
4260 }
4261
4262
4263 /* mulw. */
4264 void
4265 OP_66_8 (SIM_DESC sd, SIM_CPU *cpu)
4266 {
4267 int32 tmp;
4268 uint16 a = OP[0];
4269 int16 b = (GPR (OP[1]));
4270 trace_input ("mulw", OP_CONSTANT4_1, OP_REG, OP_VOID);
4271 tmp = (a * b) & 0xffff;
4272 SET_GPR (OP[1], tmp);
4273 trace_output_32 (sd, tmp);
4274 }
4275
4276 /* mulw. */
4277 void
4278 OP_66B_C (SIM_DESC sd, SIM_CPU *cpu)
4279 {
4280 int32 tmp;
4281 int16 a = OP[0], b = (GPR (OP[1]));
4282 trace_input ("mulw", OP_CONSTANT4, OP_REG, OP_VOID);
4283 tmp = (a * b) & 0xffff;
4284 SET_GPR (OP[1], tmp);
4285 trace_output_32 (sd, tmp);
4286 }
4287
4288
4289 /* mulw. */
4290 void
4291 OP_67_8 (SIM_DESC sd, SIM_CPU *cpu)
4292 {
4293 int32 tmp;
4294 int16 a = (GPR (OP[0])), b = (GPR (OP[1]));
4295 trace_input ("mulw", OP_REG, OP_REG, OP_VOID);
4296 tmp = (a * b) & 0xffff;
4297 SET_GPR (OP[1], tmp);
4298 trace_output_32 (sd, tmp);
4299 }
4300
4301
4302 /* mulsb. */
4303 void
4304 OP_B_8 (SIM_DESC sd, SIM_CPU *cpu)
4305 {
4306 int16 tmp;
4307 int8 a = (GPR (OP[0])) & 0xff, b = (GPR (OP[1])) & 0xff;
4308 trace_input ("mulsb", OP_REG, OP_REG, OP_VOID);
4309 tmp = a * b;
4310 SET_GPR (OP[1], tmp);
4311 trace_output_32 (sd, tmp);
4312 }
4313
4314 /* mulsw. */
4315 void
4316 OP_62_8 (SIM_DESC sd, SIM_CPU *cpu)
4317 {
4318 int32 tmp;
4319 int16 a = (GPR (OP[0])), b = (GPR (OP[1]));
4320 trace_input ("mulsw", OP_REG, OP_REGP, OP_VOID);
4321 tmp = a * b;
4322 SET_GPR32 (OP[1], tmp);
4323 trace_output_32 (sd, tmp);
4324 }
4325
4326 /* muluw. */
4327 void
4328 OP_63_8 (SIM_DESC sd, SIM_CPU *cpu)
4329 {
4330 uint32 tmp;
4331 uint16 a = (GPR (OP[0])), b = (GPR (OP[1]));
4332 trace_input ("muluw", OP_REG, OP_REGP, OP_VOID);
4333 tmp = a * b;
4334 SET_GPR32 (OP[1], tmp);
4335 trace_output_32 (sd, tmp);
4336 }
4337
4338
4339 /* nop. */
4340 void
4341 OP_2C00_10 (SIM_DESC sd, SIM_CPU *cpu)
4342 {
4343 trace_input ("nop", OP_VOID, OP_VOID, OP_VOID);
4344
4345 #if 0
4346 ins_type_counters[ (int)State.ins_type ]--; /* don't count nops as normal instructions */
4347 switch (State.ins_type)
4348 {
4349 default:
4350 ins_type_counters[ (int)INS_UNKNOWN ]++;
4351 break;
4352
4353 }
4354 EXCEPTION (SIM_SIGTRAP);
4355 #endif
4356 trace_output_void (sd);
4357 }
4358
4359
4360 /* orb. */
4361 void
4362 OP_24_8 (SIM_DESC sd, SIM_CPU *cpu)
4363 {
4364 uint8 tmp, a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
4365 trace_input ("orb", OP_CONSTANT4, OP_REG, OP_VOID);
4366 tmp = a | b;
4367 SET_GPR (OP[1], ((GPR (OP[1]) | tmp)));
4368 trace_output_16 (sd, tmp);
4369 }
4370
4371 /* orb. */
4372 void
4373 OP_24B_C (SIM_DESC sd, SIM_CPU *cpu)
4374 {
4375 uint8 tmp, a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
4376 trace_input ("orb", OP_CONSTANT16, OP_REG, OP_VOID);
4377 tmp = a | b;
4378 SET_GPR (OP[1], ((GPR (OP[1]) | tmp)));
4379 trace_output_16 (sd, tmp);
4380 }
4381
4382 /* orb. */
4383 void
4384 OP_25_8 (SIM_DESC sd, SIM_CPU *cpu)
4385 {
4386 uint8 tmp, a = (GPR (OP[0])) & 0xff, b = (GPR (OP[1])) & 0xff;
4387 trace_input ("orb", OP_REG, OP_REG, OP_VOID);
4388 tmp = a | b;
4389 SET_GPR (OP[1], ((GPR (OP[1]) | tmp)));
4390 trace_output_16 (sd, tmp);
4391 }
4392
4393 /* orw. */
4394 void
4395 OP_26_8 (SIM_DESC sd, SIM_CPU *cpu)
4396 {
4397 uint16 tmp, a = (OP[0]), b = (GPR (OP[1]));
4398 trace_input ("orw", OP_CONSTANT4, OP_REG, OP_VOID);
4399 tmp = a | b;
4400 SET_GPR (OP[1], tmp);
4401 trace_output_16 (sd, tmp);
4402 }
4403
4404
4405 /* orw. */
4406 void
4407 OP_26B_C (SIM_DESC sd, SIM_CPU *cpu)
4408 {
4409 uint16 tmp, a = (OP[0]), b = (GPR (OP[1]));
4410 trace_input ("orw", OP_CONSTANT16, OP_REG, OP_VOID);
4411 tmp = a | b;
4412 SET_GPR (OP[1], tmp);
4413 trace_output_16 (sd, tmp);
4414 }
4415
4416 /* orw. */
4417 void
4418 OP_27_8 (SIM_DESC sd, SIM_CPU *cpu)
4419 {
4420 uint16 tmp, a = (GPR (OP[0])), b = (GPR (OP[1]));
4421 trace_input ("orw", OP_REG, OP_REG, OP_VOID);
4422 tmp = a | b;
4423 SET_GPR (OP[1], tmp);
4424 trace_output_16 (sd, tmp);
4425 }
4426
4427
4428 /* lshb. */
4429 void
4430 OP_13_9 (SIM_DESC sd, SIM_CPU *cpu)
4431 {
4432 uint16 a = OP[0];
4433 uint16 tmp, b = (GPR (OP[1])) & 0xFF;
4434 trace_input ("lshb", OP_CONSTANT4, OP_REG, OP_VOID);
4435 /* A positive count specifies a shift to the left;
4436 * A negative count specifies a shift to the right. */
4437 if (sign_flag)
4438 tmp = b >> a;
4439 else
4440 tmp = b << a;
4441
4442 sign_flag = 0; /* Reset sign_flag. */
4443
4444 SET_GPR (OP[1], ((tmp & 0xFF) | ((GPR (OP[1])) & 0xFF00)));
4445 trace_output_16 (sd, tmp);
4446 }
4447
4448 /* lshb. */
4449 void
4450 OP_44_8 (SIM_DESC sd, SIM_CPU *cpu)
4451 {
4452 uint16 a = (GPR (OP[0])) & 0xff;
4453 uint16 tmp, b = (GPR (OP[1])) & 0xFF;
4454 trace_input ("lshb", OP_REG, OP_REG, OP_VOID);
4455 if (a & ((long)1 << 3))
4456 {
4457 sign_flag = 1;
4458 a = ~(a) + 1;
4459 }
4460 a = (unsigned int) (a & 0x7);
4461
4462 /* A positive count specifies a shift to the left;
4463 * A negative count specifies a shift to the right. */
4464 if (sign_flag)
4465 tmp = b >> a;
4466 else
4467 tmp = b << a;
4468
4469 sign_flag = 0; /* Reset sign_flag. */
4470 SET_GPR (OP[1], ((tmp & 0xFF) | ((GPR (OP[1])) & 0xFF00)));
4471 trace_output_16 (sd, tmp);
4472 }
4473
4474 /* lshw. */
4475 void
4476 OP_46_8 (SIM_DESC sd, SIM_CPU *cpu)
4477 {
4478 uint16 tmp, b = GPR (OP[1]);
4479 int16 a = GPR (OP[0]);
4480 trace_input ("lshw", OP_REG, OP_REG, OP_VOID);
4481 if (a & ((long)1 << 4))
4482 {
4483 sign_flag = 1;
4484 a = ~(a) + 1;
4485 }
4486 a = (unsigned int) (a & 0xf);
4487
4488 /* A positive count specifies a shift to the left;
4489 * A negative count specifies a shift to the right. */
4490 if (sign_flag)
4491 tmp = b >> a;
4492 else
4493 tmp = b << a;
4494
4495 sign_flag = 0; /* Reset sign_flag. */
4496 SET_GPR (OP[1], (tmp & 0xffff));
4497 trace_output_16 (sd, tmp);
4498 }
4499
4500 /* lshw. */
4501 void
4502 OP_49_8 (SIM_DESC sd, SIM_CPU *cpu)
4503 {
4504 uint16 tmp, b = GPR (OP[1]);
4505 uint16 a = OP[0];
4506 trace_input ("lshw", OP_CONSTANT5, OP_REG, OP_VOID);
4507 /* A positive count specifies a shift to the left;
4508 * A negative count specifies a shift to the right. */
4509 if (sign_flag)
4510 tmp = b >> a;
4511 else
4512 tmp = b << a;
4513
4514 sign_flag = 0; /* Reset sign_flag. */
4515 SET_GPR (OP[1], (tmp & 0xffff));
4516 trace_output_16 (sd, tmp);
4517 }
4518
4519 /* lshd. */
4520 void
4521 OP_25_7 (SIM_DESC sd, SIM_CPU *cpu)
4522 {
4523 uint32 tmp, b = GPR32 (OP[1]);
4524 uint16 a = OP[0];
4525 trace_input ("lshd", OP_CONSTANT6, OP_REGP, OP_VOID);
4526 /* A positive count specifies a shift to the left;
4527 * A negative count specifies a shift to the right. */
4528 if (sign_flag)
4529 tmp = b >> a;
4530 else
4531 tmp = b << a;
4532
4533 sign_flag = 0; /* Reset sign flag. */
4534
4535 SET_GPR32 (OP[1], tmp);
4536 trace_output_32 (sd, tmp);
4537 }
4538
4539 /* lshd. */
4540 void
4541 OP_47_8 (SIM_DESC sd, SIM_CPU *cpu)
4542 {
4543 uint32 tmp, b = GPR32 (OP[1]);
4544 uint16 a = GPR (OP[0]);
4545 trace_input ("lshd", OP_REG, OP_REGP, OP_VOID);
4546 if (a & ((long)1 << 5))
4547 {
4548 sign_flag = 1;
4549 a = ~(a) + 1;
4550 }
4551 a = (unsigned int) (a & 0x1f);
4552 /* A positive count specifies a shift to the left;
4553 * A negative count specifies a shift to the right. */
4554 if (sign_flag)
4555 tmp = b >> a;
4556 else
4557 tmp = b << a;
4558
4559 sign_flag = 0; /* Reset sign flag. */
4560
4561 SET_GPR32 (OP[1], tmp);
4562 trace_output_32 (sd, tmp);
4563 }
4564
4565 /* ashub. */
4566 void
4567 OP_80_9 (SIM_DESC sd, SIM_CPU *cpu)
4568 {
4569 uint16 a = OP[0];
4570 int8 tmp, b = (GPR (OP[1])) & 0xFF;
4571 trace_input ("ashub", OP_CONSTANT4, OP_REG, OP_VOID);
4572 /* A positive count specifies a shift to the left;
4573 * A negative count specifies a shift to the right. */
4574 if (sign_flag)
4575 tmp = b >> a;
4576 else
4577 tmp = b << a;
4578
4579 sign_flag = 0; /* Reset sign flag. */
4580
4581 SET_GPR (OP[1], ((tmp & 0xFF) | ((GPR (OP[1])) & 0xff00)));
4582 trace_output_16 (sd, tmp);
4583 }
4584
4585 /* ashub. */
4586 void
4587 OP_81_9 (SIM_DESC sd, SIM_CPU *cpu)
4588 {
4589 uint16 a = OP[0];
4590 int8 tmp, b = (GPR (OP[1])) & 0xFF;
4591 trace_input ("ashub", OP_CONSTANT4, OP_REG, OP_VOID);
4592 /* A positive count specifies a shift to the left;
4593 * A negative count specifies a shift to the right. */
4594 if (sign_flag)
4595 tmp = b >> a;
4596 else
4597 tmp = b << a;
4598
4599 sign_flag = 0; /* Reset sign flag. */
4600
4601 SET_GPR (OP[1], ((tmp & 0xFF) | ((GPR (OP[1])) & 0xFF00)));
4602 trace_output_16 (sd, tmp);
4603 }
4604
4605
4606 /* ashub. */
4607 void
4608 OP_41_8 (SIM_DESC sd, SIM_CPU *cpu)
4609 {
4610 int16 a = (GPR (OP[0]));
4611 int8 tmp, b = (GPR (OP[1])) & 0xFF;
4612 trace_input ("ashub", OP_REG, OP_REG, OP_VOID);
4613
4614 if (a & ((long)1 << 3))
4615 {
4616 sign_flag = 1;
4617 a = ~(a) + 1;
4618 }
4619 a = (unsigned int) (a & 0x7);
4620
4621 /* A positive count specifies a shift to the left;
4622 * A negative count specifies a shift to the right. */
4623 if (sign_flag)
4624 tmp = b >> a;
4625 else
4626 tmp = b << a;
4627
4628 sign_flag = 0; /* Reset sign flag. */
4629
4630 SET_GPR (OP[1], ((tmp & 0xFF) | ((GPR (OP[1])) & 0xFF00)));
4631 trace_output_16 (sd, tmp);
4632 }
4633
4634
4635 /* ashuw. */
4636 void
4637 OP_42_8 (SIM_DESC sd, SIM_CPU *cpu)
4638 {
4639 int16 tmp, b = GPR (OP[1]);
4640 uint16 a = OP[0];
4641 trace_input ("ashuw", OP_CONSTANT5, OP_REG, OP_VOID);
4642 /* A positive count specifies a shift to the left;
4643 * A negative count specifies a shift to the right. */
4644 if (sign_flag)
4645 tmp = b >> a;
4646 else
4647 tmp = b << a;
4648
4649 sign_flag = 0; /* Reset sign flag. */
4650
4651 SET_GPR (OP[1], (tmp & 0xffff));
4652 trace_output_16 (sd, tmp);
4653 }
4654
4655 /* ashuw. */
4656 void
4657 OP_43_8 (SIM_DESC sd, SIM_CPU *cpu)
4658 {
4659 int16 tmp, b = GPR (OP[1]);
4660 uint16 a = OP[0];
4661 trace_input ("ashuw", OP_CONSTANT5, OP_REG, OP_VOID);
4662 /* A positive count specifies a shift to the left;
4663 * A negative count specifies a shift to the right. */
4664 if (sign_flag)
4665 tmp = b >> a;
4666 else
4667 tmp = b << a;
4668
4669 sign_flag = 0; /* Reset sign flag. */
4670 SET_GPR (OP[1], (tmp & 0xffff));
4671 trace_output_16 (sd, tmp);
4672 }
4673
4674 /* ashuw. */
4675 void
4676 OP_45_8 (SIM_DESC sd, SIM_CPU *cpu)
4677 {
4678 int16 tmp;
4679 int16 a = GPR (OP[0]), b = GPR (OP[1]);
4680 trace_input ("ashuw", OP_REG, OP_REG, OP_VOID);
4681
4682 if (a & ((long)1 << 4))
4683 {
4684 sign_flag = 1;
4685 a = ~(a) + 1;
4686 }
4687 a = (unsigned int) (a & 0xf);
4688 /* A positive count specifies a shift to the left;
4689 * A negative count specifies a shift to the right. */
4690
4691 if (sign_flag)
4692 tmp = b >> a;
4693 else
4694 tmp = b << a;
4695
4696 sign_flag = 0; /* Reset sign flag. */
4697 SET_GPR (OP[1], (tmp & 0xffff));
4698 trace_output_16 (sd, tmp);
4699 }
4700
4701 /* ashud. */
4702 void
4703 OP_26_7 (SIM_DESC sd, SIM_CPU *cpu)
4704 {
4705 int32 tmp,b = GPR32 (OP[1]);
4706 uint32 a = OP[0];
4707 trace_input ("ashud", OP_CONSTANT6, OP_REGP, OP_VOID);
4708 /* A positive count specifies a shift to the left;
4709 * A negative count specifies a shift to the right. */
4710 if (sign_flag)
4711 tmp = b >> a;
4712 else
4713 tmp = b << a;
4714
4715 sign_flag = 0; /* Reset sign flag. */
4716 SET_GPR32 (OP[1], tmp);
4717 trace_output_32 (sd, tmp);
4718 }
4719
4720 /* ashud. */
4721 void
4722 OP_27_7 (SIM_DESC sd, SIM_CPU *cpu)
4723 {
4724 int32 tmp;
4725 int32 a = OP[0], b = GPR32 (OP[1]);
4726 trace_input ("ashud", OP_CONSTANT6, OP_REGP, OP_VOID);
4727 /* A positive count specifies a shift to the left;
4728 * A negative count specifies a shift to the right. */
4729 if (sign_flag)
4730 tmp = b >> a;
4731 else
4732 tmp = b << a;
4733
4734 sign_flag = 0; /* Reset sign flag. */
4735 SET_GPR32 (OP[1], tmp);
4736 trace_output_32 (sd, tmp);
4737 }
4738
4739 /* ashud. */
4740 void
4741 OP_48_8 (SIM_DESC sd, SIM_CPU *cpu)
4742 {
4743 int32 tmp;
4744 int32 a = GPR32 (OP[0]), b = GPR32 (OP[1]);
4745 trace_input ("ashud", OP_REGP, OP_REGP, OP_VOID);
4746
4747 if (a & ((long)1 << 5))
4748 {
4749 sign_flag = 1;
4750 a = ~(a) + 1;
4751 }
4752 a = (unsigned int) (a & 0x1f);
4753 /* A positive count specifies a shift to the left;
4754 * A negative count specifies a shift to the right. */
4755 if (sign_flag)
4756 tmp = b >> a;
4757 else
4758 tmp = b << a;
4759
4760 sign_flag = 0; /* Reset sign flag. */
4761 SET_GPR32 (OP[1], tmp);
4762 trace_output_32 (sd, tmp);
4763 }
4764
4765
4766 /* storm. */
4767 void
4768 OP_16_D (SIM_DESC sd, SIM_CPU *cpu)
4769 {
4770 uint32 addr = GPR (1);
4771 uint16 count = OP[0], reg = 2;
4772 trace_input ("storm", OP_CONSTANT4, OP_VOID, OP_VOID);
4773 if ((addr & 1))
4774 {
4775 trace_output_void (sd);
4776 EXCEPTION (SIM_SIGBUS);
4777 }
4778
4779 while (count)
4780 {
4781 SW (addr, (GPR (reg)));
4782 addr +=2;
4783 --count;
4784 reg++;
4785 if (reg == 6) reg = 8;
4786 };
4787
4788 SET_GPR (1, addr);
4789
4790 trace_output_void (sd);
4791 }
4792
4793
4794 /* stormp. */
4795 void
4796 OP_17_D (SIM_DESC sd, SIM_CPU *cpu)
4797 {
4798 uint32 addr = GPR32 (6);
4799 uint16 count = OP[0], reg = 2;
4800 trace_input ("stormp", OP_CONSTANT4, OP_VOID, OP_VOID);
4801 if ((addr & 1))
4802 {
4803 trace_output_void (sd);
4804 EXCEPTION (SIM_SIGBUS);
4805 }
4806
4807 while (count)
4808 {
4809 SW (addr, (GPR (reg)));
4810 addr +=2;
4811 --count;
4812 reg++;
4813 if (reg == 6) reg = 8;
4814 };
4815
4816 SET_GPR32 (6, addr);
4817 trace_output_void (sd);
4818 }
4819
4820 /* subb. */
4821 void
4822 OP_38_8 (SIM_DESC sd, SIM_CPU *cpu)
4823 {
4824 uint8 a = OP[0];
4825 uint8 b = (GPR (OP[1])) & 0xff;
4826 uint16 tmp = (~a + 1 + b) & 0xff;
4827 trace_input ("subb", OP_CONSTANT4, OP_REG, OP_VOID);
4828 /* see ../common/sim-alu.h for a more extensive discussion on how to
4829 compute the carry/overflow bits. */
4830 SET_PSR_C (tmp > 0xff);
4831 SET_PSR_F (((a & 0x80) != (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
4832 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
4833 trace_output_16 (sd, tmp);
4834 }
4835
4836 /* subb. */
4837 void
4838 OP_38B_C (SIM_DESC sd, SIM_CPU *cpu)
4839 {
4840 uint8 a = OP[0] & 0xFF;
4841 uint8 b = (GPR (OP[1])) & 0xFF;
4842 uint16 tmp = (~a + 1 + b) & 0xFF;
4843 trace_input ("subb", OP_CONSTANT16, OP_REG, OP_VOID);
4844 /* see ../common/sim-alu.h for a more extensive discussion on how to
4845 compute the carry/overflow bits. */
4846 SET_PSR_C (tmp > 0xff);
4847 SET_PSR_F (((a & 0x80) != (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
4848 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
4849 trace_output_16 (sd, tmp);
4850 }
4851
4852 /* subb. */
4853 void
4854 OP_39_8 (SIM_DESC sd, SIM_CPU *cpu)
4855 {
4856 uint8 a = (GPR (OP[0])) & 0xFF;
4857 uint8 b = (GPR (OP[1])) & 0xFF;
4858 uint16 tmp = (~a + 1 + b) & 0xff;
4859 trace_input ("subb", OP_REG, OP_REG, OP_VOID);
4860 /* see ../common/sim-alu.h for a more extensive discussion on how to
4861 compute the carry/overflow bits. */
4862 SET_PSR_C (tmp > 0xff);
4863 SET_PSR_F (((a & 0x80) != (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
4864 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
4865 trace_output_16 (sd, tmp);
4866 }
4867
4868 /* subw. */
4869 void
4870 OP_3A_8 (SIM_DESC sd, SIM_CPU *cpu)
4871 {
4872 uint16 a = OP[0];
4873 uint16 b = GPR (OP[1]);
4874 uint16 tmp = (~a + 1 + b);
4875 trace_input ("subw", OP_CONSTANT4, OP_REG, OP_VOID);
4876 /* see ../common/sim-alu.h for a more extensive discussion on how to
4877 compute the carry/overflow bits. */
4878 SET_PSR_C (tmp > 0xffff);
4879 SET_PSR_F (((a & 0x8000) != (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
4880 SET_GPR (OP[1], tmp);
4881 trace_output_16 (sd, tmp);
4882 }
4883
4884 /* subw. */
4885 void
4886 OP_3AB_C (SIM_DESC sd, SIM_CPU *cpu)
4887 {
4888 uint16 a = OP[0];
4889 uint16 b = GPR (OP[1]);
4890 uint32 tmp = (~a + 1 + b);
4891 trace_input ("subw", OP_CONSTANT16, OP_REG, OP_VOID);
4892 /* see ../common/sim-alu.h for a more extensive discussion on how to
4893 compute the carry/overflow bits. */
4894 SET_PSR_C (tmp > 0xffff);
4895 SET_PSR_F (((a & 0x8000) != (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
4896 SET_GPR (OP[1], tmp & 0xffff);
4897 trace_output_16 (sd, tmp);
4898 }
4899
4900 /* subw. */
4901 void
4902 OP_3B_8 (SIM_DESC sd, SIM_CPU *cpu)
4903 {
4904 uint16 a = GPR (OP[0]);
4905 uint16 b = GPR (OP[1]);
4906 uint32 tmp = (~a + 1 + b);
4907 trace_input ("subw", OP_REG, OP_REG, OP_VOID);
4908 /* see ../common/sim-alu.h for a more extensive discussion on how to
4909 compute the carry/overflow bits. */
4910 SET_PSR_C (tmp > 0xffff);
4911 SET_PSR_F (((a & 0x8000) != (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
4912 SET_GPR (OP[1], tmp & 0xffff);
4913 trace_output_16 (sd, tmp);
4914 }
4915
4916 /* subcb. */
4917 void
4918 OP_3C_8 (SIM_DESC sd, SIM_CPU *cpu)
4919 {
4920 uint8 a = OP[0];
4921 uint8 b = (GPR (OP[1])) & 0xff;
4922 //uint16 tmp1 = a + 1;
4923 uint16 tmp1 = a + (PSR_C);
4924 uint16 tmp = (~tmp1 + 1 + b);
4925 trace_input ("subcb", OP_CONSTANT4, OP_REG, OP_VOID);
4926 /* see ../common/sim-alu.h for a more extensive discussion on how to
4927 compute the carry/overflow bits. */
4928 SET_PSR_C (tmp > 0xff);
4929 SET_PSR_F (((a & 0x80) != (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
4930 SET_GPR (OP[1], tmp);
4931 trace_output_16 (sd, tmp);
4932 }
4933
4934 /* subcb. */
4935 void
4936 OP_3CB_C (SIM_DESC sd, SIM_CPU *cpu)
4937 {
4938 uint16 a = OP[0];
4939 uint16 b = (GPR (OP[1])) & 0xff;
4940 //uint16 tmp1 = a + 1;
4941 uint16 tmp1 = a + (PSR_C);
4942 uint16 tmp = (~tmp1 + 1 + b);
4943 trace_input ("subcb", OP_CONSTANT16, OP_REG, OP_VOID);
4944 /* see ../common/sim-alu.h for a more extensive discussion on how to
4945 compute the carry/overflow bits. */
4946 SET_PSR_C (tmp > 0xff);
4947 SET_PSR_F (((a & 0x80) != (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
4948 SET_GPR (OP[1], tmp);
4949 trace_output_16 (sd, tmp);
4950 }
4951
4952 /* subcb. */
4953 void
4954 OP_3D_8 (SIM_DESC sd, SIM_CPU *cpu)
4955 {
4956 uint16 a = (GPR (OP[0])) & 0xff;
4957 uint16 b = (GPR (OP[1])) & 0xff;
4958 uint16 tmp1 = a + (PSR_C);
4959 uint16 tmp = (~tmp1 + 1 + b);
4960 trace_input ("subcb", OP_REG, OP_REG, OP_VOID);
4961 /* see ../common/sim-alu.h for a more extensive discussion on how to
4962 compute the carry/overflow bits. */
4963 SET_PSR_C (tmp > 0xff);
4964 SET_PSR_F (((a & 0x80) != (b & 0x80)) && ((b & 0x80) != (tmp & 0x80)));
4965 SET_GPR (OP[1], tmp);
4966 trace_output_16 (sd, tmp);
4967 }
4968
4969 /* subcw. */
4970 void
4971 OP_3E_8 (SIM_DESC sd, SIM_CPU *cpu)
4972 {
4973 uint16 a = OP[0], b = (GPR (OP[1]));
4974 uint16 tmp1 = a + (PSR_C);
4975 uint16 tmp = (~tmp1 + 1 + b);
4976 trace_input ("subcw", OP_CONSTANT4, OP_REG, OP_VOID);
4977 /* see ../common/sim-alu.h for a more extensive discussion on how to
4978 compute the carry/overflow bits. */
4979 SET_PSR_C (tmp > 0xffff);
4980 SET_PSR_F (((a & 0x8000) != (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
4981 SET_GPR (OP[1], tmp);
4982 trace_output_16 (sd, tmp);
4983 }
4984
4985 /* subcw. */
4986 void
4987 OP_3EB_C (SIM_DESC sd, SIM_CPU *cpu)
4988 {
4989 int16 a = OP[0];
4990 uint16 b = GPR (OP[1]);
4991 uint16 tmp1 = a + (PSR_C);
4992 uint16 tmp = (~tmp1 + 1 + b);
4993 trace_input ("subcw", OP_CONSTANT16, OP_REG, OP_VOID);
4994 /* see ../common/sim-alu.h for a more extensive discussion on how to
4995 compute the carry/overflow bits. */
4996 SET_PSR_C (tmp > 0xffff);
4997 SET_PSR_F (((a & 0x8000) != (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
4998 SET_GPR (OP[1], tmp);
4999 trace_output_16 (sd, tmp);
5000 }
5001
5002 /* subcw. */
5003 void
5004 OP_3F_8 (SIM_DESC sd, SIM_CPU *cpu)
5005 {
5006 uint16 a = (GPR (OP[0])), b = (GPR (OP[1]));
5007 uint16 tmp1 = a + (PSR_C);
5008 uint16 tmp = (~tmp1 + 1 + b);
5009 trace_input ("subcw", OP_REG, OP_REG, OP_VOID);
5010 /* see ../common/sim-alu.h for a more extensive discussion on how to
5011 compute the carry/overflow bits. */
5012 SET_PSR_C (tmp > 0xffff);
5013 SET_PSR_F (((a & 0x8000) != (b & 0x8000)) && ((b & 0x8000) != (tmp & 0x8000)));
5014 SET_GPR (OP[1], tmp);
5015 trace_output_16 (sd, tmp);
5016 }
5017
5018 /* subd. */
5019 void
5020 OP_3_C (SIM_DESC sd, SIM_CPU *cpu)
5021 {
5022 int32 a = OP[0];
5023 uint32 b = GPR32 (OP[1]);
5024 uint32 tmp = (~a + 1 + b);
5025 trace_input ("subd", OP_CONSTANT32, OP_REGP, OP_VOID);
5026 /* see ../common/sim-alu.h for a more extensive discussion on how to
5027 compute the carry/overflow bits. */
5028 SET_PSR_C (tmp > 0xffffffff);
5029 SET_PSR_F (((a & 0x80000000) != (b & 0x80000000)) &&
5030 ((b & 0x80000000) != (tmp & 0x80000000)));
5031 SET_GPR32 (OP[1], tmp);
5032 trace_output_32 (sd, tmp);
5033 }
5034
5035 /* subd. */
5036 void
5037 OP_14C_14 (SIM_DESC sd, SIM_CPU *cpu)
5038 {
5039 uint32 a = GPR32 (OP[0]);
5040 uint32 b = GPR32 (OP[1]);
5041 uint32 tmp = (~a + 1 + b);
5042 trace_input ("subd", OP_REGP, OP_REGP, OP_VOID);
5043 /* see ../common/sim-alu.h for a more extensive discussion on how to
5044 compute the carry/overflow bits. */
5045 SET_PSR_C (tmp > 0xffffffff);
5046 SET_PSR_F (((a & 0x80000000) != (b & 0x80000000)) &&
5047 ((b & 0x80000000) != (tmp & 0x80000000)));
5048 SET_GPR32 (OP[1], tmp);
5049 trace_output_32 (sd, tmp);
5050 }
5051
5052 /* excp. */
5053 void
5054 OP_C_C (SIM_DESC sd, SIM_CPU *cpu)
5055 {
5056 host_callback *cb = STATE_CALLBACK (sd);
5057 uint32 tmp;
5058 uint16 a;
5059 trace_input ("excp", OP_CONSTANT4, OP_VOID, OP_VOID);
5060 switch (OP[0])
5061 {
5062 default:
5063 #if (DEBUG & DEBUG_TRAP) == 0
5064 {
5065 #if 0
5066 uint16 vec = OP[0] + TRAP_VECTOR_START;
5067 SET_BPC (PC + 1);
5068 SET_BPSR (PSR);
5069 SET_PSR (PSR & PSR_SM_BIT);
5070 JMP (vec);
5071 break;
5072 #endif
5073 }
5074 #else /* if debugging use trap to print registers */
5075 {
5076 int i;
5077 static int first_time = 1;
5078
5079 if (first_time)
5080 {
5081 first_time = 0;
5082 sim_io_printf (sd, "Trap # PC ");
5083 for (i = 0; i < 16; i++)
5084 sim_io_printf (sd, " %sr%d", (i > 9) ? "" : " ", i);
5085 sim_io_printf (sd, " a0 a1 f0 f1 c\n");
5086 }
5087
5088 sim_io_printf (sd, "Trap %2d 0x%.4x:", (int)OP[0], (int)PC);
5089
5090 for (i = 0; i < 16; i++)
5091 sim_io_printf (sd, " %.4x", (int) GPR (i));
5092
5093 for (i = 0; i < 2; i++)
5094 sim_io_printf (sd, " %.2x%.8lx",
5095 ((int)(ACC (i) >> 32) & 0xff),
5096 ((unsigned long) ACC (i)) & 0xffffffff);
5097
5098 sim_io_printf (sd, " %d %d %d\n",
5099 PSR_F != 0, PSR_F != 0, PSR_C != 0);
5100 sim_io_flush_stdout (sd);
5101 break;
5102 }
5103 #endif
5104 case 8: /* new system call trap */
5105 /* Trap 8 is used for simulating low-level I/O */
5106 {
5107 unsigned32 result = 0;
5108 errno = 0;
5109
5110 /* Registers passed to trap 0. */
5111
5112 #define FUNC GPR (0) /* function number. */
5113 #define PARM1 GPR (2) /* optional parm 1. */
5114 #define PARM2 GPR (3) /* optional parm 2. */
5115 #define PARM3 GPR (4) /* optional parm 3. */
5116 #define PARM4 GPR (5) /* optional parm 4. */
5117
5118 /* Registers set by trap 0 */
5119
5120 #define RETVAL(X) do { result = (0xffff & (X));SET_GPR (0, result);} while (0)
5121 #define RETVAL32(X) do { result = (X); SET_GPR32 (0, result);} while (0)
5122 #define RETERR(X) SET_GPR (4, (X)) /* return error code. */
5123
5124 /* Turn a pointer in a register into a pointer into real memory. */
5125
5126 #define MEMPTR(x) sim_core_trans_addr (sd, cpu, read_map, x)
5127
5128 switch (FUNC)
5129 {
5130 #if !defined(__GO32__) && !defined(_WIN32)
5131 #ifdef TARGET_SYS_fork
5132 case TARGET_SYS_fork:
5133 trace_input ("<fork>", OP_VOID, OP_VOID, OP_VOID);
5134 RETVAL (fork ());
5135 trace_output_16 (sd, result);
5136 break;
5137 #endif
5138
5139 #define getpid() 47
5140 case TARGET_SYS_getpid:
5141 trace_input ("<getpid>", OP_VOID, OP_VOID, OP_VOID);
5142 RETVAL (getpid ());
5143 trace_output_16 (sd, result);
5144 break;
5145
5146 case TARGET_SYS_kill:
5147 trace_input ("<kill>", OP_REG, OP_REG, OP_VOID);
5148 if (PARM1 == getpid ())
5149 {
5150 trace_output_void (sd);
5151 EXCEPTION (PARM2);
5152 }
5153 else
5154 {
5155 int os_sig = -1;
5156 switch (PARM2)
5157 {
5158 #ifdef SIGHUP
5159 case 1: os_sig = SIGHUP; break;
5160 #endif
5161 #ifdef SIGINT
5162 case 2: os_sig = SIGINT; break;
5163 #endif
5164 #ifdef SIGQUIT
5165 case 3: os_sig = SIGQUIT; break;
5166 #endif
5167 #ifdef SIGILL
5168 case 4: os_sig = SIGILL; break;
5169 #endif
5170 #ifdef SIGTRAP
5171 case 5: os_sig = SIGTRAP; break;
5172 #endif
5173 #ifdef SIGABRT
5174 case 6: os_sig = SIGABRT; break;
5175 #elif defined(SIGIOT)
5176 case 6: os_sig = SIGIOT; break;
5177 #endif
5178 #ifdef SIGEMT
5179 case 7: os_sig = SIGEMT; break;
5180 #endif
5181 #ifdef SIGFPE
5182 case 8: os_sig = SIGFPE; break;
5183 #endif
5184 #ifdef SIGKILL
5185 case 9: os_sig = SIGKILL; break;
5186 #endif
5187 #ifdef SIGBUS
5188 case 10: os_sig = SIGBUS; break;
5189 #endif
5190 #ifdef SIGSEGV
5191 case 11: os_sig = SIGSEGV; break;
5192 #endif
5193 #ifdef SIGSYS
5194 case 12: os_sig = SIGSYS; break;
5195 #endif
5196 #ifdef SIGPIPE
5197 case 13: os_sig = SIGPIPE; break;
5198 #endif
5199 #ifdef SIGALRM
5200 case 14: os_sig = SIGALRM; break;
5201 #endif
5202 #ifdef SIGTERM
5203 case 15: os_sig = SIGTERM; break;
5204 #endif
5205 #ifdef SIGURG
5206 case 16: os_sig = SIGURG; break;
5207 #endif
5208 #ifdef SIGSTOP
5209 case 17: os_sig = SIGSTOP; break;
5210 #endif
5211 #ifdef SIGTSTP
5212 case 18: os_sig = SIGTSTP; break;
5213 #endif
5214 #ifdef SIGCONT
5215 case 19: os_sig = SIGCONT; break;
5216 #endif
5217 #ifdef SIGCHLD
5218 case 20: os_sig = SIGCHLD; break;
5219 #elif defined(SIGCLD)
5220 case 20: os_sig = SIGCLD; break;
5221 #endif
5222 #ifdef SIGTTIN
5223 case 21: os_sig = SIGTTIN; break;
5224 #endif
5225 #ifdef SIGTTOU
5226 case 22: os_sig = SIGTTOU; break;
5227 #endif
5228 #ifdef SIGIO
5229 case 23: os_sig = SIGIO; break;
5230 #elif defined (SIGPOLL)
5231 case 23: os_sig = SIGPOLL; break;
5232 #endif
5233 #ifdef SIGXCPU
5234 case 24: os_sig = SIGXCPU; break;
5235 #endif
5236 #ifdef SIGXFSZ
5237 case 25: os_sig = SIGXFSZ; break;
5238 #endif
5239 #ifdef SIGVTALRM
5240 case 26: os_sig = SIGVTALRM; break;
5241 #endif
5242 #ifdef SIGPROF
5243 case 27: os_sig = SIGPROF; break;
5244 #endif
5245 #ifdef SIGWINCH
5246 case 28: os_sig = SIGWINCH; break;
5247 #endif
5248 #ifdef SIGLOST
5249 case 29: os_sig = SIGLOST; break;
5250 #endif
5251 #ifdef SIGUSR1
5252 case 30: os_sig = SIGUSR1; break;
5253 #endif
5254 #ifdef SIGUSR2
5255 case 31: os_sig = SIGUSR2; break;
5256 #endif
5257 }
5258
5259 if (os_sig == -1)
5260 {
5261 trace_output_void (sd);
5262 sim_io_printf (sd, "Unknown signal %d\n", PARM2);
5263 sim_io_flush_stdout (sd);
5264 EXCEPTION (SIM_SIGILL);
5265 }
5266 else
5267 {
5268 RETVAL (kill (PARM1, PARM2));
5269 trace_output_16 (sd, result);
5270 }
5271 }
5272 break;
5273
5274 #ifdef TARGET_SYS_execve
5275 case TARGET_SYS_execve:
5276 trace_input ("<execve>", OP_VOID, OP_VOID, OP_VOID);
5277 RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2<<16|PARM3),
5278 (char **)MEMPTR (PARM4)));
5279 trace_output_16 (sd, result);
5280 break;
5281 #endif
5282
5283 #ifdef TARGET_SYS_execv
5284 case TARGET_SYS_execv:
5285 trace_input ("<execv>", OP_VOID, OP_VOID, OP_VOID);
5286 RETVAL (execve (MEMPTR (PARM1), (char **) MEMPTR (PARM2), NULL));
5287 trace_output_16 (sd, result);
5288 break;
5289 #endif
5290
5291 #ifdef TARGET_SYS_pipe
5292 case TARGET_SYS_pipe:
5293 {
5294 reg_t buf;
5295 int host_fd[2];
5296
5297 trace_input ("<pipe>", OP_VOID, OP_VOID, OP_VOID);
5298 buf = PARM1;
5299 RETVAL (pipe (host_fd));
5300 SW (buf, host_fd[0]);
5301 buf += sizeof(uint16);
5302 SW (buf, host_fd[1]);
5303 trace_output_16 (sd, result);
5304 }
5305 break;
5306 #endif
5307
5308 #ifdef TARGET_SYS_wait
5309 case TARGET_SYS_wait:
5310 {
5311 int status;
5312 trace_input ("<wait>", OP_REG, OP_VOID, OP_VOID);
5313 RETVAL (wait (&status));
5314 if (PARM1)
5315 SW (PARM1, status);
5316 trace_output_16 (sd, result);
5317 }
5318 break;
5319 #endif
5320 #else
5321 case TARGET_SYS_getpid:
5322 trace_input ("<getpid>", OP_VOID, OP_VOID, OP_VOID);
5323 RETVAL (1);
5324 trace_output_16 (sd, result);
5325 break;
5326
5327 case TARGET_SYS_kill:
5328 trace_input ("<kill>", OP_REG, OP_REG, OP_VOID);
5329 trace_output_void (sd);
5330 EXCEPTION (PARM2);
5331 break;
5332 #endif
5333
5334 case TARGET_SYS_read:
5335 trace_input ("<read>", OP_REG, OP_MEMREF, OP_REG);
5336 RETVAL (cb->read (cb, PARM1,
5337 MEMPTR (((unsigned long)PARM3 << 16)
5338 | ((unsigned long)PARM2)), PARM4));
5339 trace_output_16 (sd, result);
5340 break;
5341
5342 case TARGET_SYS_write:
5343 trace_input ("<write>", OP_REG, OP_MEMREF, OP_REG);
5344 RETVAL ((int)cb->write (cb, PARM1,
5345 MEMPTR (((unsigned long)PARM3 << 16)
5346 | PARM2), PARM4));
5347 trace_output_16 (sd, result);
5348 break;
5349
5350 case TARGET_SYS_lseek:
5351 trace_input ("<lseek>", OP_REG, OP_REGP, OP_REG);
5352 RETVAL32 (cb->lseek (cb, PARM1, ((((long) PARM3) << 16) | PARM2),
5353 PARM4));
5354 trace_output_32 (sd, result);
5355 break;
5356
5357 case TARGET_SYS_close:
5358 trace_input ("<close>", OP_REG, OP_VOID, OP_VOID);
5359 RETVAL (cb->close (cb, PARM1));
5360 trace_output_16 (sd, result);
5361 break;
5362
5363 case TARGET_SYS_open:
5364 trace_input ("<open>", OP_MEMREF, OP_REG, OP_VOID);
5365 RETVAL32 (cb->open (cb, MEMPTR ((((unsigned long)PARM2) << 16)
5366 | PARM1), PARM3));
5367 trace_output_32 (sd, result);
5368 break;
5369
5370 #ifdef TARGET_SYS_rename
5371 case TARGET_SYS_rename:
5372 trace_input ("<rename>", OP_MEMREF, OP_MEMREF, OP_VOID);
5373 RETVAL (cb->rename (cb, MEMPTR ((((unsigned long)PARM2) << 16) | PARM1),
5374 MEMPTR ((((unsigned long)PARM4) << 16) | PARM3)));
5375 trace_output_16 (sd, result);
5376 break;
5377 #endif
5378
5379 case 0x408: /* REVISIT: Added a dummy getenv call. */
5380 trace_input ("<getenv>", OP_MEMREF, OP_MEMREF, OP_VOID);
5381 RETVAL32 (0);
5382 trace_output_32 (sd, result);
5383 break;
5384
5385 case TARGET_SYS_exit:
5386 trace_input ("<exit>", OP_VOID, OP_VOID, OP_VOID);
5387 trace_output_void (sd);
5388 sim_engine_halt (sd, cpu, NULL, PC, sim_exited, GPR (2));
5389 break;
5390
5391 case TARGET_SYS_unlink:
5392 trace_input ("<unlink>", OP_MEMREF, OP_VOID, OP_VOID);
5393 RETVAL (cb->unlink (cb, MEMPTR (((unsigned long)PARM2 << 16) | PARM1)));
5394 trace_output_16 (sd, result);
5395 break;
5396
5397
5398 #ifdef TARGET_SYS_stat
5399 case TARGET_SYS_stat:
5400 trace_input ("<stat>", OP_VOID, OP_VOID, OP_VOID);
5401 /* stat system call. */
5402 {
5403 struct stat host_stat;
5404 reg_t buf;
5405
5406 RETVAL (stat (MEMPTR ((((unsigned long)PARM2) << 16)|PARM1), &host_stat));
5407
5408 buf = PARM2;
5409
5410 /* The hard-coded offsets and sizes were determined by using
5411 * the CR16 compiler on a test program that used struct stat.
5412 */
5413 SW (buf, host_stat.st_dev);
5414 SW (buf+2, host_stat.st_ino);
5415 SW (buf+4, host_stat.st_mode);
5416 SW (buf+6, host_stat.st_nlink);
5417 SW (buf+8, host_stat.st_uid);
5418 SW (buf+10, host_stat.st_gid);
5419 SW (buf+12, host_stat.st_rdev);
5420 SLW (buf+16, host_stat.st_size);
5421 SLW (buf+20, host_stat.st_atime);
5422 SLW (buf+28, host_stat.st_mtime);
5423 SLW (buf+36, host_stat.st_ctime);
5424 }
5425 trace_output_16 (sd, result);
5426 break;
5427 #endif
5428
5429 #ifdef TARGET_SYS_chown
5430 case TARGET_SYS_chown:
5431 trace_input ("<chown>", OP_VOID, OP_VOID, OP_VOID);
5432 RETVAL (chown (MEMPTR (PARM1), PARM2, PARM3));
5433 trace_output_16 (sd, result);
5434 break;
5435 #endif
5436
5437 case TARGET_SYS_chmod:
5438 trace_input ("<chmod>", OP_VOID, OP_VOID, OP_VOID);
5439 RETVAL (chmod (MEMPTR (PARM1), PARM2));
5440 trace_output_16 (sd, result);
5441 break;
5442
5443 #ifdef TARGET_SYS_utime
5444 case TARGET_SYS_utime:
5445 trace_input ("<utime>", OP_REG, OP_REG, OP_REG);
5446 /* Cast the second argument to void *, to avoid type mismatch
5447 if a prototype is present. */
5448 RETVAL (utime (MEMPTR (PARM1), (void *) MEMPTR (PARM2)));
5449 trace_output_16 (sd, result);
5450 break;
5451 #endif
5452
5453 #ifdef TARGET_SYS_time
5454 case TARGET_SYS_time:
5455 trace_input ("<time>", OP_VOID, OP_VOID, OP_REG);
5456 RETVAL32 (time (NULL));
5457 trace_output_32 (sd, result);
5458 break;
5459 #endif
5460
5461 default:
5462 a = OP[0];
5463 switch (a)
5464 {
5465 case TRAP_BREAKPOINT:
5466 tmp = (PC);
5467 JMP(tmp);
5468 trace_output_void (sd);
5469 EXCEPTION (SIM_SIGTRAP);
5470 break;
5471 case SIGTRAP: /* supervisor call ? */
5472 trace_output_void (sd);
5473 sim_engine_halt (sd, cpu, NULL, PC, sim_exited, GPR (2));
5474 break;
5475 default:
5476 cb->error (cb, "Unknown syscall %d", FUNC);
5477 break;
5478 }
5479 }
5480 if ((uint16) result == (uint16) -1)
5481 RETERR (cb->get_errno (cb));
5482 else
5483 RETERR (0);
5484 break;
5485 }
5486 }
5487 }
5488
5489
5490 /* push. */
5491 void
5492 OP_3_9 (SIM_DESC sd, SIM_CPU *cpu)
5493 {
5494 uint16 a = OP[0] + 1, b = OP[1], c = OP[2], i = 0;
5495 uint32 tmp, sp_addr = (GPR32 (15)) - (a * 2) - 4, is_regp = 0;
5496 trace_input ("push", OP_CONSTANT3, OP_REG, OP_REG);
5497
5498 for (; i < a; ++i)
5499 {
5500 if ((b+i) <= 11)
5501 {
5502 SW (sp_addr, (GPR (b+i)));
5503 sp_addr +=2;
5504 }
5505 else
5506 {
5507 if (is_regp == 0)
5508 tmp = (GPR32 (b+i));
5509 else
5510 tmp = (GPR32 (b+i-1));
5511
5512 if ((a-i) > 1)
5513 {
5514 SLW (sp_addr, tmp);
5515 sp_addr +=4;
5516 }
5517 else
5518 {
5519 SW (sp_addr, tmp);
5520 sp_addr +=2;
5521 }
5522 ++i;
5523 is_regp = 1;
5524 }
5525 }
5526
5527 sp_addr +=4;
5528
5529 /* Store RA address. */
5530 tmp = (GPR32 (14));
5531 SLW(sp_addr,tmp);
5532
5533 sp_addr = (GPR32 (15)) - (a * 2) - 4;
5534 SET_GPR32 (15, sp_addr); /* Update SP address. */
5535
5536 trace_output_void (sd);
5537 }
5538
5539 /* push. */
5540 void
5541 OP_1_8 (SIM_DESC sd, SIM_CPU *cpu)
5542 {
5543 uint32 sp_addr, tmp, is_regp = 0;
5544 uint16 a = OP[0] + 1, b = OP[1], c = OP[2], i = 0;
5545 trace_input ("push", OP_CONSTANT3, OP_REG, OP_VOID);
5546
5547 if (c == 1)
5548 sp_addr = (GPR32 (15)) - (a * 2) - 4;
5549 else
5550 sp_addr = (GPR32 (15)) - (a * 2);
5551
5552 for (; i < a; ++i)
5553 {
5554 if ((b+i) <= 11)
5555 {
5556 SW (sp_addr, (GPR (b+i)));
5557 sp_addr +=2;
5558 }
5559 else
5560 {
5561 if (is_regp == 0)
5562 tmp = (GPR32 (b+i));
5563 else
5564 tmp = (GPR32 (b+i-1));
5565
5566 if ((a-i) > 1)
5567 {
5568 SLW (sp_addr, tmp);
5569 sp_addr +=4;
5570 }
5571 else
5572 {
5573 SW (sp_addr, tmp);
5574 sp_addr +=2;
5575 }
5576 ++i;
5577 is_regp = 1;
5578 }
5579 }
5580
5581 if (c == 1)
5582 {
5583 /* Store RA address. */
5584 tmp = (GPR32 (14));
5585 SLW(sp_addr,tmp);
5586 sp_addr = (GPR32 (15)) - (a * 2) - 4;
5587 }
5588 else
5589 sp_addr = (GPR32 (15)) - (a * 2);
5590
5591 SET_GPR32 (15, sp_addr); /* Update SP address. */
5592
5593 trace_output_void (sd);
5594 }
5595
5596
5597 /* push. */
5598 void
5599 OP_11E_10 (SIM_DESC sd, SIM_CPU *cpu)
5600 {
5601 uint32 sp_addr = (GPR32 (15)), tmp;
5602 trace_input ("push", OP_VOID, OP_VOID, OP_VOID);
5603 tmp = (GPR32 (14));
5604 SLW(sp_addr-4,tmp); /* Store RA address. */
5605 SET_GPR32 (15, (sp_addr - 4)); /* Update SP address. */
5606 trace_output_void (sd);
5607 }
5608
5609
5610 /* pop. */
5611 void
5612 OP_5_9 (SIM_DESC sd, SIM_CPU *cpu)
5613 {
5614 uint16 a = OP[0] + 1, b = OP[1], c = OP[2], i = 0;
5615 uint32 tmp, sp_addr = (GPR32 (15)), is_regp = 0;;
5616 trace_input ("pop", OP_CONSTANT3, OP_REG, OP_REG);
5617
5618 for (; i < a; ++i)
5619 {
5620 if ((b+i) <= 11)
5621 {
5622 SET_GPR ((b+i), RW(sp_addr));
5623 sp_addr +=2;
5624 }
5625 else
5626 {
5627 if ((a-i) > 1)
5628 {
5629 tmp = RLW(sp_addr);
5630 sp_addr +=4;
5631 }
5632 else
5633 {
5634 tmp = RW(sp_addr);
5635 sp_addr +=2;
5636
5637 if (is_regp == 0)
5638 tmp = (tmp << 16) | (GPR32 (b+i));
5639 else
5640 tmp = (tmp << 16) | (GPR32 (b+i-1));
5641 }
5642
5643 if (is_regp == 0)
5644 SET_GPR32 ((b+i), (((tmp & 0xffff) << 16)
5645 | ((tmp >> 16) & 0xffff)));
5646 else
5647 SET_GPR32 ((b+i-1), (((tmp & 0xffff) << 16)
5648 | ((tmp >> 16) & 0xffff)));
5649
5650 ++i;
5651 is_regp = 1;
5652 }
5653 }
5654
5655 tmp = RLW(sp_addr); /* store RA also. */
5656 SET_GPR32 (14, (((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff)));
5657
5658 SET_GPR32 (15, (sp_addr + 4)); /* Update SP address. */
5659
5660 trace_output_void (sd);
5661 }
5662
5663 /* pop. */
5664 void
5665 OP_2_8 (SIM_DESC sd, SIM_CPU *cpu)
5666 {
5667 uint16 a = OP[0] + 1, b = OP[1], c = OP[2], i = 0;
5668 uint32 tmp, sp_addr = (GPR32 (15)), is_regp = 0;
5669 trace_input ("pop", OP_CONSTANT3, OP_REG, OP_VOID);
5670
5671 for (; i < a; ++i)
5672 {
5673 if ((b+i) <= 11)
5674 {
5675 SET_GPR ((b+i), RW(sp_addr));
5676 sp_addr +=2;
5677 }
5678 else
5679 {
5680 if ((a-i) > 1)
5681 {
5682 tmp = RLW(sp_addr);
5683 sp_addr +=4;
5684 }
5685 else
5686 {
5687 tmp = RW(sp_addr);
5688 sp_addr +=2;
5689
5690 if (is_regp == 0)
5691 tmp = ((tmp << 16) & 0xffffffff) | (GPR32 (b+i));
5692 else
5693 tmp = ((tmp << 16) & 0xffffffff) | (GPR32 (b+i-1));
5694 }
5695
5696 if (is_regp == 0)
5697 SET_GPR32 ((b+i), (((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff)));
5698 else
5699 SET_GPR32 ((b+i-1), (((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff)));
5700 ++i;
5701 is_regp = 1;
5702 }
5703 }
5704
5705 if (c == 1)
5706 {
5707 tmp = RLW(sp_addr); /* Store RA Reg. */
5708 SET_GPR32 (14, (((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff)));
5709 sp_addr +=4;
5710 }
5711
5712 SET_GPR32 (15, sp_addr); /* Update SP address. */
5713
5714 trace_output_void (sd);
5715 }
5716
5717 /* pop. */
5718 void
5719 OP_21E_10 (SIM_DESC sd, SIM_CPU *cpu)
5720 {
5721 uint32 sp_addr = GPR32 (15);
5722 uint32 tmp;
5723 trace_input ("pop", OP_VOID, OP_VOID, OP_VOID);
5724
5725 tmp = RLW(sp_addr);
5726 SET_GPR32 (14, (((tmp & 0xffff) << 16)| ((tmp >> 16) & 0xffff)));
5727 SET_GPR32 (15, (sp_addr+4)); /* Update SP address. */
5728
5729 trace_output_void (sd);
5730 }
5731
5732 /* popret. */
5733 void
5734 OP_7_9 (SIM_DESC sd, SIM_CPU *cpu)
5735 {
5736 uint16 a = OP[0], b = OP[1];
5737 trace_input ("popret", OP_CONSTANT3, OP_REG, OP_REG);
5738 OP_5_9 (sd, cpu);
5739 JMP(((GPR32(14)) << 1) & 0xffffff);
5740
5741 trace_output_void (sd);
5742 }
5743
5744 /* popret. */
5745 void
5746 OP_3_8 (SIM_DESC sd, SIM_CPU *cpu)
5747 {
5748 uint16 a = OP[0], b = OP[1];
5749 trace_input ("popret", OP_CONSTANT3, OP_REG, OP_VOID);
5750 OP_2_8 (sd, cpu);
5751 JMP(((GPR32(14)) << 1) & 0xffffff);
5752
5753 trace_output_void (sd);
5754 }
5755
5756 /* popret. */
5757 void
5758 OP_31E_10 (SIM_DESC sd, SIM_CPU *cpu)
5759 {
5760 uint32 tmp;
5761 trace_input ("popret", OP_VOID, OP_VOID, OP_VOID);
5762 OP_21E_10 (sd, cpu);
5763 tmp = (((GPR32(14)) << 1) & 0xffffff);
5764 /* If the resulting PC value is less than 0x00_0000 or greater
5765 than 0xFF_FFFF, this instruction causes an IAD trap.*/
5766
5767 if ((tmp < 0x0) || (tmp > 0xFFFFFF))
5768 {
5769 trace_output_void (sd);
5770 EXCEPTION (SIM_SIGBUS);
5771 }
5772 else
5773 JMP (tmp);
5774
5775 trace_output_32 (sd, tmp);
5776 }
5777
5778
5779 /* cinv[i]. */
5780 void
5781 OP_A_10 (SIM_DESC sd, SIM_CPU *cpu)
5782 {
5783 trace_input ("cinv[i]", OP_VOID, OP_VOID, OP_VOID);
5784 SET_PSR_I (1);
5785 trace_output_void (sd);
5786 }
5787
5788 /* cinv[i,u]. */
5789 void
5790 OP_B_10 (SIM_DESC sd, SIM_CPU *cpu)
5791 {
5792 trace_input ("cinv[i,u]", OP_VOID, OP_VOID, OP_VOID);
5793 SET_PSR_I (1);
5794 trace_output_void (sd);
5795 }
5796
5797 /* cinv[d]. */
5798 void
5799 OP_C_10 (SIM_DESC sd, SIM_CPU *cpu)
5800 {
5801 trace_input ("cinv[d]", OP_VOID, OP_VOID, OP_VOID);
5802 SET_PSR_I (1);
5803 trace_output_void (sd);
5804 }
5805
5806 /* cinv[d,u]. */
5807 void
5808 OP_D_10 (SIM_DESC sd, SIM_CPU *cpu)
5809 {
5810 trace_input ("cinv[i,u]", OP_VOID, OP_VOID, OP_VOID);
5811 SET_PSR_I (1);
5812 trace_output_void (sd);
5813 }
5814
5815 /* cinv[d,i]. */
5816 void
5817 OP_E_10 (SIM_DESC sd, SIM_CPU *cpu)
5818 {
5819 trace_input ("cinv[d,i]", OP_VOID, OP_VOID, OP_VOID);
5820 SET_PSR_I (1);
5821 trace_output_void (sd);
5822 }
5823
5824 /* cinv[d,i,u]. */
5825 void
5826 OP_F_10 (SIM_DESC sd, SIM_CPU *cpu)
5827 {
5828 trace_input ("cinv[d,i,u]", OP_VOID, OP_VOID, OP_VOID);
5829 SET_PSR_I (1);
5830 trace_output_void (sd);
5831 }
5832
5833 /* retx. */
5834 void
5835 OP_3_10 (SIM_DESC sd, SIM_CPU *cpu)
5836 {
5837 trace_input ("retx", OP_VOID, OP_VOID, OP_VOID);
5838 SET_PSR_I (1);
5839 trace_output_void (sd);
5840 }
5841
5842 /* di. */
5843 void
5844 OP_4_10 (SIM_DESC sd, SIM_CPU *cpu)
5845 {
5846 trace_input ("di", OP_VOID, OP_VOID, OP_VOID);
5847 SET_PSR_I (1);
5848 trace_output_void (sd);
5849 }
5850
5851 /* ei. */
5852 void
5853 OP_5_10 (SIM_DESC sd, SIM_CPU *cpu)
5854 {
5855 trace_input ("ei", OP_VOID, OP_VOID, OP_VOID);
5856 SET_PSR_I (1);
5857 trace_output_void (sd);
5858 }
5859
5860 /* wait. */
5861 void
5862 OP_6_10 (SIM_DESC sd, SIM_CPU *cpu)
5863 {
5864 trace_input ("wait", OP_VOID, OP_VOID, OP_VOID);
5865 trace_output_void (sd);
5866 EXCEPTION (SIM_SIGTRAP);
5867 }
5868
5869 /* ewait. */
5870 void
5871 OP_7_10 (SIM_DESC sd, SIM_CPU *cpu)
5872 {
5873 trace_input ("ewait", OP_VOID, OP_VOID, OP_VOID);
5874 SET_PSR_I (1);
5875 trace_output_void (sd);
5876 }
5877
5878 /* xorb. */
5879 void
5880 OP_28_8 (SIM_DESC sd, SIM_CPU *cpu)
5881 {
5882 uint8 tmp, a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
5883 trace_input ("xorb", OP_CONSTANT4, OP_REG, OP_VOID);
5884 tmp = a ^ b;
5885 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
5886 trace_output_16 (sd, tmp);
5887 }
5888
5889 /* xorb. */
5890 void
5891 OP_28B_C (SIM_DESC sd, SIM_CPU *cpu)
5892 {
5893 uint8 tmp, a = (OP[0]) & 0xff, b = (GPR (OP[1])) & 0xff;
5894 trace_input ("xorb", OP_CONSTANT16, OP_REG, OP_VOID);
5895 tmp = a ^ b;
5896 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
5897 trace_output_16 (sd, tmp);
5898 }
5899
5900 /* xorb. */
5901 void
5902 OP_29_8 (SIM_DESC sd, SIM_CPU *cpu)
5903 {
5904 uint8 tmp, a = (GPR (OP[0])) & 0xff, b = (GPR (OP[1])) & 0xff;
5905 trace_input ("xorb", OP_REG, OP_REG, OP_VOID);
5906 tmp = a ^ b;
5907 SET_GPR (OP[1], (tmp | ((GPR (OP[1])) & 0xff00)));
5908 trace_output_16 (sd, tmp);
5909 }
5910
5911 /* xorw. */
5912 void
5913 OP_2A_8 (SIM_DESC sd, SIM_CPU *cpu)
5914 {
5915 uint16 tmp, a = (OP[0]), b = (GPR (OP[1]));
5916 trace_input ("xorw", OP_CONSTANT4, OP_REG, OP_VOID);
5917 tmp = a ^ b;
5918 SET_GPR (OP[1], tmp);
5919 trace_output_16 (sd, tmp);
5920 }
5921
5922 /* xorw. */
5923 void
5924 OP_2AB_C (SIM_DESC sd, SIM_CPU *cpu)
5925 {
5926 uint16 tmp, a = (OP[0]), b = (GPR (OP[1]));
5927 trace_input ("xorw", OP_CONSTANT16, OP_REG, OP_VOID);
5928 tmp = a ^ b;
5929 SET_GPR (OP[1], tmp);
5930 trace_output_16 (sd, tmp);
5931 }
5932
5933 /* xorw. */
5934 void
5935 OP_2B_8 (SIM_DESC sd, SIM_CPU *cpu)
5936 {
5937 uint16 tmp, a = (GPR (OP[0])), b = (GPR (OP[1]));
5938 trace_input ("xorw", OP_REG, OP_REG, OP_VOID);
5939 tmp = a ^ b;
5940 SET_GPR (OP[1], tmp);
5941 trace_output_16 (sd, tmp);
5942 }
5943
5944 /*REVISIT FOR LPR/SPR . */
5945
5946 /* lpr. */
5947 void
5948 OP_140_14 (SIM_DESC sd, SIM_CPU *cpu)
5949 {
5950 uint16 a = GPR (OP[0]);
5951 trace_input ("lpr", OP_REG, OP_REG, OP_VOID);
5952 SET_CREG (OP[1], a);
5953 trace_output_16 (sd, a);
5954 }
5955
5956 /* lprd. */
5957 void
5958 OP_141_14 (SIM_DESC sd, SIM_CPU *cpu)
5959 {
5960 uint32 a = GPR32 (OP[0]);
5961 trace_input ("lprd", OP_REGP, OP_REG, OP_VOID);
5962 SET_CREG (OP[1], a);
5963 trace_output_flag (sd);
5964 }
5965
5966 /* spr. */
5967 void
5968 OP_142_14 (SIM_DESC sd, SIM_CPU *cpu)
5969 {
5970 uint16 a = CREG (OP[0]);
5971 trace_input ("spr", OP_REG, OP_REG, OP_VOID);
5972 SET_GPR (OP[1], a);
5973 trace_output_16 (sd, a);
5974 }
5975
5976 /* sprd. */
5977 void
5978 OP_143_14 (SIM_DESC sd, SIM_CPU *cpu)
5979 {
5980 uint32 a = CREG (OP[0]);
5981 trace_input ("sprd", OP_REGP, OP_REGP, OP_VOID);
5982 SET_GPR32 (OP[1], a);
5983 trace_output_32 (sd, a);
5984 }
5985
5986 /* null. */
5987 void
5988 OP_0_20 (SIM_DESC sd, SIM_CPU *cpu)
5989 {
5990 trace_input ("null", OP_VOID, OP_VOID, OP_VOID);
5991 sim_engine_halt (sd, cpu, NULL, PC, sim_exited, 0);
5992 }
The GNU Binutils are a collection of binary tools.