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