projects / deliverable / binutils-gdb.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
* simops (OP_10007E0): Update errno handling as most traps
[deliverable/binutils-gdb.git] / sim / v850 / simops.c
CommitLineData
c906108c
SS		 1#include "sim-main.h"
2#include "v850_sim.h"
3#include "simops.h"
4
4389ce38
MK		 5#include <sys/types.h>
6
c906108c
SS		 7#ifdef HAVE_UTIME_H
8#include <utime.h>
9#endif
10
11#ifdef HAVE_TIME_H
12#include <time.h>
13#endif
14
15#ifdef HAVE_UNISTD_H
16#include <unistd.h>
17#endif
18
19#ifdef HAVE_STRING_H
20#include <string.h>
21#else
22#ifdef HAVE_STRINGS_H
23#include <strings.h>
24#endif
25#endif
26
27#include "targ-vals.h"
28
29#include "libiberty.h"
30
31#include <errno.h>
32#if !defined(__GO32__) && !defined(_WIN32)
33#include <sys/stat.h>
34#include <sys/times.h>
35#include <sys/time.h>
36#endif
37
38/* This is an array of the bit positions of registers r20 .. r31 in
39 that order in a prepare/dispose instruction. */
40int type1_regs[12] = { 27, 26, 25, 24, 31, 30, 29, 28, 23, 22, 0, 21 };
41/* This is an array of the bit positions of registers r16 .. r31 in
42 that order in a push/pop instruction. */
43int type2_regs[16] = { 3, 2, 1, 0, 27, 26, 25, 24, 31, 30, 29, 28, 23, 22, 20, 21};
44/* This is an array of the bit positions of registers r1 .. r15 in
45 that order in a push/pop instruction. */
46int type3_regs[15] = { 2, 1, 0, 27, 26, 25, 24, 31, 30, 29, 28, 23, 22, 20, 21};
47
48#ifdef DEBUG
49#ifndef SIZE_INSTRUCTION
50#define SIZE_INSTRUCTION 18
51#endif
52
53#ifndef SIZE_VALUES
54#define SIZE_VALUES 11
55#endif
56
57
58unsigned32 trace_values[3];
59int trace_num_values;
60unsigned32 trace_pc;
61const char *trace_name;
62int trace_module;
63
64
65void
66trace_input (name, type, size)
67 char *name;
68 enum op_types type;
69 int size;
70{
71
72 if (!TRACE_ALU_P (STATE_CPU (simulator, 0)))
73 return;
74
75 trace_pc = PC;
76 trace_name = name;
77 trace_module = TRACE_ALU_IDX;
78
79 switch (type)
80 {
81 default:
82 case OP_UNKNOWN:
83 case OP_NONE:
84 case OP_TRAP:
85 trace_num_values = 0;
86 break;
87
88 case OP_REG:
89 case OP_REG_REG_MOVE:
90 trace_values[0] = State.regs[OP[0]];
91 trace_num_values = 1;
92 break;
93
94 case OP_BIT_CHANGE:
95 case OP_REG_REG:
96 case OP_REG_REG_CMP:
97 trace_values[0] = State.regs[OP[1]];
98 trace_values[1] = State.regs[OP[0]];
99 trace_num_values = 2;
100 break;
101
102 case OP_IMM_REG:
103 case OP_IMM_REG_CMP:
104 trace_values[0] = SEXT5 (OP[0]);
105 trace_values[1] = OP[1];
106 trace_num_values = 2;
107 break;
108
109 case OP_IMM_REG_MOVE:
110 trace_values[0] = SEXT5 (OP[0]);
111 trace_num_values = 1;
112 break;
113
114 case OP_COND_BR:
115 trace_values[0] = State.pc;
116 trace_values[1] = SEXT9 (OP[0]);
117 trace_values[2] = PSW;
118 trace_num_values = 3;
119 break;
120
121 case OP_LOAD16:
122 trace_values[0] = OP[1] * size;
123 trace_values[1] = State.regs[30];
124 trace_num_values = 2;
125 break;
126
127 case OP_STORE16:
128 trace_values[0] = State.regs[OP[0]];
129 trace_values[1] = OP[1] * size;
130 trace_values[2] = State.regs[30];
131 trace_num_values = 3;
132 break;
133
134 case OP_LOAD32:
135 trace_values[0] = EXTEND16 (OP[2]);
136 trace_values[1] = State.regs[OP[0]];
137 trace_num_values = 2;
138 break;
139
140 case OP_STORE32:
141 trace_values[0] = State.regs[OP[1]];
142 trace_values[1] = EXTEND16 (OP[2]);
143 trace_values[2] = State.regs[OP[0]];
144 trace_num_values = 3;
145 break;
146
147 case OP_JUMP:
148 trace_values[0] = SEXT22 (OP[0]);
149 trace_values[1] = State.pc;
150 trace_num_values = 2;
151 break;
152
153 case OP_IMM_REG_REG:
154 trace_values[0] = EXTEND16 (OP[0]) << size;
155 trace_values[1] = State.regs[OP[1]];
156 trace_num_values = 2;
157 break;
158
159 case OP_IMM16_REG_REG:
160 trace_values[0] = EXTEND16 (OP[2]) << size;
161 trace_values[1] = State.regs[OP[1]];
162 trace_num_values = 2;
163 break;
164
165 case OP_UIMM_REG_REG:
166 trace_values[0] = (OP[0] & 0xffff) << size;
167 trace_values[1] = State.regs[OP[1]];
168 trace_num_values = 2;
169 break;
170
171 case OP_UIMM16_REG_REG:
172 trace_values[0] = (OP[2]) << size;
173 trace_values[1] = State.regs[OP[1]];
174 trace_num_values = 2;
175 break;
176
177 case OP_BIT:
178 trace_num_values = 0;
179 break;
180
181 case OP_EX1:
182 trace_values[0] = PSW;
183 trace_num_values = 1;
184 break;
185
186 case OP_EX2:
187 trace_num_values = 0;
188 break;
189
190 case OP_LDSR:
191 trace_values[0] = State.regs[OP[0]];
192 trace_num_values = 1;
193 break;
194
195 case OP_STSR:
196 trace_values[0] = State.sregs[OP[1]];
197 trace_num_values = 1;
198 }
199
200}
201
202void
203trace_result (int has_result, unsigned32 result)
204{
205 char buf[1000];
206 char *chp;
207
208 buf[0] = '\0';
209 chp = buf;
210
211 /* write out the values saved during the trace_input call */
212 {
213 int i;
214 for (i = 0; i < trace_num_values; i++)
215 {
d62274a3
AC		 216 sprintf (chp, "%*s0x%.8lx", SIZE_VALUES - 10, "",
217 (long) trace_values[i]);
c906108c
SS		 218 chp = strchr (chp, '\0');
219 }
220 while (i++ < 3)
221 {
222 sprintf (chp, "%*s", SIZE_VALUES, "");
223 chp = strchr (chp, '\0');
224 }
225 }
226
227 /* append any result to the end of the buffer */
228 if (has_result)
229 sprintf (chp, " :: 0x%.8lx", (unsigned long)result);
230
231 trace_generic (simulator, STATE_CPU (simulator, 0), trace_module, buf);
232}
233
234void
235trace_output (result)
236 enum op_types result;
237{
238 if (!TRACE_ALU_P (STATE_CPU (simulator, 0)))
239 return;
240
241 switch (result)
242 {
243 default:
244 case OP_UNKNOWN:
245 case OP_NONE:
246 case OP_TRAP:
247 case OP_REG:
248 case OP_REG_REG_CMP:
249 case OP_IMM_REG_CMP:
250 case OP_COND_BR:
251 case OP_STORE16:
252 case OP_STORE32:
253 case OP_BIT:
254 case OP_EX2:
255 trace_result (0, 0);
256 break;
257
258 case OP_LOAD16:
259 case OP_STSR:
260 trace_result (1, State.regs[OP[0]]);
261 break;
262
263 case OP_REG_REG:
264 case OP_REG_REG_MOVE:
265 case OP_IMM_REG:
266 case OP_IMM_REG_MOVE:
267 case OP_LOAD32:
268 case OP_EX1:
269 trace_result (1, State.regs[OP[1]]);
270 break;
271
272 case OP_IMM_REG_REG:
273 case OP_UIMM_REG_REG:
274 case OP_IMM16_REG_REG:
275 case OP_UIMM16_REG_REG:
276 trace_result (1, State.regs[OP[1]]);
277 break;
278
279 case OP_JUMP:
280 if (OP[1] != 0)
281 trace_result (1, State.regs[OP[1]]);
282 else
283 trace_result (0, 0);
284 break;
285
286 case OP_LDSR:
287 trace_result (1, State.sregs[OP[1]]);
288 break;
289 }
290}
291#endif
292
293\f
294/* Returns 1 if the specific condition is met, returns 0 otherwise. */
295int
296condition_met (unsigned code)
297{
298 unsigned int psw = PSW;
299
300 switch (code & 0xf)
301 {
302 case 0x0: return ((psw & PSW_OV) != 0);
303 case 0x1: return ((psw & PSW_CY) != 0);
304 case 0x2: return ((psw & PSW_Z) != 0);
305 case 0x3: return ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) != 0);
306 case 0x4: return ((psw & PSW_S) != 0);
307 /*case 0x5: return 1;*/
308 case 0x6: return ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) != 0);
309 case 0x7: return (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) || ((psw & PSW_Z) != 0)) != 0);
310 case 0x8: return ((psw & PSW_OV) == 0);
311 case 0x9: return ((psw & PSW_CY) == 0);
312 case 0xa: return ((psw & PSW_Z) == 0);
313 case 0xb: return ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) == 0);
314 case 0xc: return ((psw & PSW_S) == 0);
315 case 0xd: return ((psw & PSW_SAT) != 0);
316 case 0xe: return ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) == 0);
317 case 0xf: return (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) || ((psw & PSW_Z) != 0)) == 0);
318 }
319
320 return 1;
321}
322
323static unsigned long
324Add32 (unsigned long a1, unsigned long a2, int * carry)
325{
326 unsigned long result = (a1 + a2);
327
328 * carry = (result < a1);
329
330 return result;
331}
332
333static void
0da2b665 334Multiply64 (int sign, unsigned long op0)
c906108c
SS		 335{
336 unsigned long op1;
337 unsigned long lo;
338 unsigned long mid1;
339 unsigned long mid2;
340 unsigned long hi;
341 unsigned long RdLo;
342 unsigned long RdHi;
343 int carry;
344
345 op1 = State.regs[ OP[1] ];
346
347 if (sign)
348 {
349 /* Compute sign of result and adjust operands if necessary. */
350
351 sign = (op0 ^ op1) & 0x80000000;
352
353 if (((signed long) op0) < 0)
354 op0 = - op0;
355
356 if (((signed long) op1) < 0)
357 op1 = - op1;
358 }
359
360 /* We can split the 32x32 into four 16x16 operations. This ensures
361 that we do not lose precision on 32bit only hosts: */
362 lo = ( (op0 & 0xFFFF) * (op1 & 0xFFFF));
363 mid1 = ( (op0 & 0xFFFF) * ((op1 >> 16) & 0xFFFF));
364 mid2 = (((op0 >> 16) & 0xFFFF) * (op1 & 0xFFFF));
365 hi = (((op0 >> 16) & 0xFFFF) * ((op1 >> 16) & 0xFFFF));
366
367 /* We now need to add all of these results together, taking care
368 to propogate the carries from the additions: */
369 RdLo = Add32 (lo, (mid1 << 16), & carry);
370 RdHi = carry;
371 RdLo = Add32 (RdLo, (mid2 << 16), & carry);
372 RdHi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi);
373
374 if (sign)
375 {
376 /* Negate result if necessary. */
377
378 RdLo = ~ RdLo;
379 RdHi = ~ RdHi;
380 if (RdLo == 0xFFFFFFFF)
381 {
382 RdLo = 0;
383 RdHi += 1;
384 }
385 else
386 RdLo += 1;
387 }
388
389 /* Don't store into register 0. */
390 if (OP[1])
391 State.regs[ OP[1] ] = RdLo;
392 if (OP[2] >> 11)
393 State.regs[ OP[2] >> 11 ] = RdHi;
394
395 return;
396}
397
398\f
399/* Read a null terminated string from memory, return in a buffer */
400static char *
401fetch_str (sd, addr)
402 SIM_DESC sd;
403 address_word addr;
404{
405 char *buf;
406 int nr = 0;
407 while (sim_core_read_1 (STATE_CPU (sd, 0),
408 PC, read_map, addr + nr) != 0)
409 nr++;
410 buf = NZALLOC (char, nr + 1);
411 sim_read (simulator, addr, buf, nr);
412 return buf;
413}
414
415/* Read a null terminated argument vector from memory, return in a
416 buffer */
417static char **
418fetch_argv (sd, addr)
419 SIM_DESC sd;
420 address_word addr;
421{
422 int max_nr = 64;
423 int nr = 0;
424 char **buf = xmalloc (max_nr * sizeof (char*));
425 while (1)
426 {
427 unsigned32 a = sim_core_read_4 (STATE_CPU (sd, 0),
428 PC, read_map, addr + nr * 4);
429 if (a == 0) break;
430 buf[nr] = fetch_str (sd, a);
431 nr ++;
432 if (nr == max_nr - 1)
433 {
434 max_nr += 50;
435 buf = xrealloc (buf, max_nr * sizeof (char*));
436 }
437 }
438 buf[nr] = 0;
439 return buf;
440}
441
442\f
443/* sst.b */
444int
445OP_380 ()
446{
447 trace_input ("sst.b", OP_STORE16, 1);
448
449 store_mem (State.regs[30] + (OP[3] & 0x7f), 1, State.regs[ OP[1] ]);
450
451 trace_output (OP_STORE16);
452
453 return 2;
454}
455
456/* sst.h */
457int
458OP_480 ()
459{
460 trace_input ("sst.h", OP_STORE16, 2);
461
462 store_mem (State.regs[30] + ((OP[3] & 0x7f) << 1), 2, State.regs[ OP[1] ]);
463
464 trace_output (OP_STORE16);
465
466 return 2;
467}
468
469/* sst.w */
470int
471OP_501 ()
472{
473 trace_input ("sst.w", OP_STORE16, 4);
474
475 store_mem (State.regs[30] + ((OP[3] & 0x7e) << 1), 4, State.regs[ OP[1] ]);
476
477 trace_output (OP_STORE16);
478
479 return 2;
480}
481
482/* ld.b */
483int
484OP_700 ()
485{
486 int adr;
487
488 trace_input ("ld.b", OP_LOAD32, 1);
489
490 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
491
492 State.regs[ OP[1] ] = EXTEND8 (load_mem (adr, 1));
493
494 trace_output (OP_LOAD32);
495
496 return 4;
497}
498
499/* ld.h */
500int
501OP_720 ()
502{
503 int adr;
504
505 trace_input ("ld.h", OP_LOAD32, 2);
506
507 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
508 adr &= ~0x1;
509
510 State.regs[ OP[1] ] = EXTEND16 (load_mem (adr, 2));
511
512 trace_output (OP_LOAD32);
513
514 return 4;
515}
516
517/* ld.w */
518int
519OP_10720 ()
520{
521 int adr;
522
523 trace_input ("ld.w", OP_LOAD32, 4);
524
525 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
526 adr &= ~0x3;
527
528 State.regs[ OP[1] ] = load_mem (adr, 4);
529
530 trace_output (OP_LOAD32);
531
532 return 4;
533}
534
535/* st.b */
536int
537OP_740 ()
538{
539 trace_input ("st.b", OP_STORE32, 1);
540
541 store_mem (State.regs[ OP[0] ] + EXTEND16 (OP[2]), 1, State.regs[ OP[1] ]);
542
543 trace_output (OP_STORE32);
544
545 return 4;
546}
547
548/* st.h */
549int
550OP_760 ()
551{
552 int adr;
553
554 trace_input ("st.h", OP_STORE32, 2);
555
556 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
557 adr &= ~1;
558
559 store_mem (adr, 2, State.regs[ OP[1] ]);
560
561 trace_output (OP_STORE32);
562
563 return 4;
564}
565
566/* st.w */
567int
568OP_10760 ()
569{
570 int adr;
571
572 trace_input ("st.w", OP_STORE32, 4);
573
574 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
575 adr &= ~3;
576
577 store_mem (adr, 4, State.regs[ OP[1] ]);
578
579 trace_output (OP_STORE32);
580
581 return 4;
582}
583
584/* add reg, reg */
585int
586OP_1C0 ()
587{
588 unsigned int op0, op1, result, z, s, cy, ov;
589
590 trace_input ("add", OP_REG_REG, 0);
591
592 /* Compute the result. */
593
594 op0 = State.regs[ OP[0] ];
595 op1 = State.regs[ OP[1] ];
596
597 result = op0 + op1;
598
599 /* Compute the condition codes. */
600 z = (result == 0);
601 s = (result & 0x80000000);
602 cy = (result < op0 || result < op1);
603 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
604 && (op0 & 0x80000000) != (result & 0x80000000));
605
606 /* Store the result and condition codes. */
607 State.regs[OP[1]] = result;
608 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
609 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
610 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
611 trace_output (OP_REG_REG);
612
613 return 2;
614}
615
616/* add sign_extend(imm5), reg */
617int
618OP_240 ()
619{
620 unsigned int op0, op1, result, z, s, cy, ov;
621 int temp;
622
623 trace_input ("add", OP_IMM_REG, 0);
624
625 /* Compute the result. */
626 temp = SEXT5 (OP[0]);
627 op0 = temp;
628 op1 = State.regs[OP[1]];
629 result = op0 + op1;
630
631 /* Compute the condition codes. */
632 z = (result == 0);
633 s = (result & 0x80000000);
634 cy = (result < op0 || result < op1);
635 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
636 && (op0 & 0x80000000) != (result & 0x80000000));
637
638 /* Store the result and condition codes. */
639 State.regs[OP[1]] = result;
640 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
641 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
642 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
643 trace_output (OP_IMM_REG);
644
645 return 2;
646}
647
648/* addi sign_extend(imm16), reg, reg */
649int
650OP_600 ()
651{
652 unsigned int op0, op1, result, z, s, cy, ov;
653
654 trace_input ("addi", OP_IMM16_REG_REG, 0);
655
656 /* Compute the result. */
657
658 op0 = EXTEND16 (OP[2]);
659 op1 = State.regs[ OP[0] ];
660 result = op0 + op1;
661
662 /* Compute the condition codes. */
663 z = (result == 0);
664 s = (result & 0x80000000);
665 cy = (result < op0 || result < op1);
666 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
667 && (op0 & 0x80000000) != (result & 0x80000000));
668
669 /* Store the result and condition codes. */
670 State.regs[OP[1]] = result;
671 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
672 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
673 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
674 trace_output (OP_IMM16_REG_REG);
675
676 return 4;
677}
678
679/* sub reg1, reg2 */
680int
681OP_1A0 ()
682{
683 unsigned int op0, op1, result, z, s, cy, ov;
684
685 trace_input ("sub", OP_REG_REG, 0);
686 /* Compute the result. */
687 op0 = State.regs[ OP[0] ];
688 op1 = State.regs[ OP[1] ];
689 result = op1 - op0;
690
691 /* Compute the condition codes. */
692 z = (result == 0);
693 s = (result & 0x80000000);
694 cy = (op1 < op0);
695 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
696 && (op1 & 0x80000000) != (result & 0x80000000));
697
698 /* Store the result and condition codes. */
699 State.regs[OP[1]] = result;
700 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
701 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
702 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
703 trace_output (OP_REG_REG);
704
705 return 2;
706}
707
708/* subr reg1, reg2 */
709int
710OP_180 ()
711{
712 unsigned int op0, op1, result, z, s, cy, ov;
713
714 trace_input ("subr", OP_REG_REG, 0);
715 /* Compute the result. */
716 op0 = State.regs[ OP[0] ];
717 op1 = State.regs[ OP[1] ];
718 result = op0 - op1;
719
720 /* Compute the condition codes. */
721 z = (result == 0);
722 s = (result & 0x80000000);
723 cy = (op0 < op1);
724 ov = ((op0 & 0x80000000) != (op1 & 0x80000000)
725 && (op0 & 0x80000000) != (result & 0x80000000));
726
727 /* Store the result and condition codes. */
728 State.regs[OP[1]] = result;
729 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
730 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
731 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
732 trace_output (OP_REG_REG);
733
734 return 2;
735}
736
737/* sxh reg1 */
738int
739OP_E0 ()
740{
741 trace_input ("mulh", OP_REG_REG, 0);
742
743 State.regs[ OP[1] ] = (EXTEND16 (State.regs[ OP[1] ]) * EXTEND16 (State.regs[ OP[0] ]));
744
745 trace_output (OP_REG_REG);
746
747 return 2;
748}
749
750/* mulh sign_extend(imm5), reg2 */
751int
752OP_2E0 ()
753{
754 trace_input ("mulh", OP_IMM_REG, 0);
755
756 State.regs[ OP[1] ] = EXTEND16 (State.regs[ OP[1] ]) * SEXT5 (OP[0]);
757
758 trace_output (OP_IMM_REG);
759
760 return 2;
761}
762
763/* mulhi imm16, reg1, reg2 */
764int
765OP_6E0 ()
766{
767 trace_input ("mulhi", OP_IMM16_REG_REG, 0);
768
769 State.regs[ OP[1] ] = EXTEND16 (State.regs[ OP[0] ]) * EXTEND16 (OP[2]);
770
771 trace_output (OP_IMM16_REG_REG);
772
773 return 4;
774}
775
c906108c
SS		 776/* cmp reg, reg */
777int
778OP_1E0 ()
779{
780 unsigned int op0, op1, result, z, s, cy, ov;
781
782 trace_input ("cmp", OP_REG_REG_CMP, 0);
783 /* Compute the result. */
784 op0 = State.regs[ OP[0] ];
785 op1 = State.regs[ OP[1] ];
786 result = op1 - op0;
787
788 /* Compute the condition codes. */
789 z = (result == 0);
790 s = (result & 0x80000000);
791 cy = (op1 < op0);
792 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
793 && (op1 & 0x80000000) != (result & 0x80000000));
794
795 /* Set condition codes. */
796 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
797 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
798 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
799 trace_output (OP_REG_REG_CMP);
800
801 return 2;
802}
803
804/* cmp sign_extend(imm5), reg */
805int
806OP_260 ()
807{
808 unsigned int op0, op1, result, z, s, cy, ov;
809 int temp;
810
811 /* Compute the result. */
812 trace_input ("cmp", OP_IMM_REG_CMP, 0);
813 temp = SEXT5 (OP[0]);
814 op0 = temp;
815 op1 = State.regs[OP[1]];
816 result = op1 - op0;
817
818 /* Compute the condition codes. */
819 z = (result == 0);
820 s = (result & 0x80000000);
821 cy = (op1 < op0);
822 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
823 && (op1 & 0x80000000) != (result & 0x80000000));
824
825 /* Set condition codes. */
826 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
827 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
828 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
829 trace_output (OP_IMM_REG_CMP);
830
831 return 2;
832}
833
834/* setf cccc,reg2 */
835int
836OP_7E0 ()
837{
838 trace_input ("setf", OP_EX1, 0);
839
840 State.regs[ OP[1] ] = condition_met (OP[0]);
841
842 trace_output (OP_EX1);
843
844 return 4;
845}
846
847/* satadd reg,reg */
848int
849OP_C0 ()
850{
851 unsigned int op0, op1, result, z, s, cy, ov, sat;
852
853 trace_input ("satadd", OP_REG_REG, 0);
854 /* Compute the result. */
855 op0 = State.regs[ OP[0] ];
856 op1 = State.regs[ OP[1] ];
857 result = op0 + op1;
858
859 /* Compute the condition codes. */
860 z = (result == 0);
861 s = (result & 0x80000000);
862 cy = (result < op0 || result < op1);
863 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
864 && (op0 & 0x80000000) != (result & 0x80000000));
865 sat = ov;
866
c5fbc25b
DD		 867 /* Handle saturated results. */
868 if (sat && s)
869 {
870 /* An overflow that results in a negative result implies that we
871 became too positive. */
872 result = 0x7fffffff;
873 s = 0;
874 }
875 else if (sat)
876 {
877 /* Any other overflow must have thus been too negative. */
878 result = 0x80000000;
879 s = 1;
880 z = 0;
881 }
882
c906108c
SS		 883 /* Store the result and condition codes. */
884 State.regs[OP[1]] = result;
885 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
886 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
887 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
888 | (sat ? PSW_SAT : 0));
c5fbc25b 889
c906108c
SS		 890 trace_output (OP_REG_REG);
891
892 return 2;
893}
894
895/* satadd sign_extend(imm5), reg */
896int
897OP_220 ()
898{
899 unsigned int op0, op1, result, z, s, cy, ov, sat;
900
901 int temp;
902
903 trace_input ("satadd", OP_IMM_REG, 0);
904
905 /* Compute the result. */
906 temp = SEXT5 (OP[0]);
907 op0 = temp;
908 op1 = State.regs[OP[1]];
909 result = op0 + op1;
910
911 /* Compute the condition codes. */
912 z = (result == 0);
913 s = (result & 0x80000000);
914 cy = (result < op0 || result < op1);
915 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
916 && (op0 & 0x80000000) != (result & 0x80000000));
917 sat = ov;
918
c5fbc25b
DD		 919 /* Handle saturated results. */
920 if (sat && s)
921 {
922 /* An overflow that results in a negative result implies that we
923 became too positive. */
924 result = 0x7fffffff;
925 s = 0;
926 }
927 else if (sat)
928 {
929 /* Any other overflow must have thus been too negative. */
930 result = 0x80000000;
931 s = 1;
932 z = 0;
933 }
934
c906108c
SS		 935 /* Store the result and condition codes. */
936 State.regs[OP[1]] = result;
937 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
938 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
939 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
940 | (sat ? PSW_SAT : 0));
c906108c
SS		 941 trace_output (OP_IMM_REG);
942
943 return 2;
944}
945
946/* satsub reg1, reg2 */
947int
948OP_A0 ()
949{
950 unsigned int op0, op1, result, z, s, cy, ov, sat;
951
952 trace_input ("satsub", OP_REG_REG, 0);
953
954 /* Compute the result. */
955 op0 = State.regs[ OP[0] ];
956 op1 = State.regs[ OP[1] ];
957 result = op1 - op0;
958
959 /* Compute the condition codes. */
960 z = (result == 0);
961 s = (result & 0x80000000);
962 cy = (op1 < op0);
963 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
964 && (op1 & 0x80000000) != (result & 0x80000000));
965 sat = ov;
c5fbc25b
DD		 966
967 /* Handle saturated results. */
968 if (sat && s)
969 {
970 /* An overflow that results in a negative result implies that we
971 became too positive. */
972 result = 0x7fffffff;
973 s = 0;
974 }
975 else if (sat)
976 {
977 /* Any other overflow must have thus been too negative. */
978 result = 0x80000000;
979 s = 1;
980 z = 0;
981 }
982
c906108c
SS		 983 /* Store the result and condition codes. */
984 State.regs[OP[1]] = result;
985 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
986 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
987 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
988 | (sat ? PSW_SAT : 0));
989
c906108c
SS		 990 trace_output (OP_REG_REG);
991 return 2;
992}
993
994/* satsubi sign_extend(imm16), reg */
995int
996OP_660 ()
997{
998 unsigned int op0, op1, result, z, s, cy, ov, sat;
999 int temp;
1000
1001 trace_input ("satsubi", OP_IMM_REG, 0);
1002
1003 /* Compute the result. */
1004 temp = EXTEND16 (OP[2]);
1005 op0 = temp;
1006 op1 = State.regs[ OP[0] ];
1007 result = op1 - op0;
1008
1009 /* Compute the condition codes. */
1010 z = (result == 0);
1011 s = (result & 0x80000000);
1012 cy = (op1 < op0);
1013 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1014 && (op1 & 0x80000000) != (result & 0x80000000));
1015 sat = ov;
1016
c5fbc25b
DD		 1017 /* Handle saturated results. */
1018 if (sat && s)
1019 {
1020 /* An overflow that results in a negative result implies that we
1021 became too positive. */
1022 result = 0x7fffffff;
1023 s = 0;
1024 }
1025 else if (sat)
1026 {
1027 /* Any other overflow must have thus been too negative. */
1028 result = 0x80000000;
1029 s = 1;
1030 z = 0;
1031 }
1032
c906108c
SS		 1033 /* Store the result and condition codes. */
1034 State.regs[OP[1]] = result;
1035 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1036 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1037 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1038 | (sat ? PSW_SAT : 0));
1039
c906108c
SS		 1040 trace_output (OP_IMM_REG);
1041
1042 return 4;
1043}
1044
1045/* satsubr reg,reg */
1046int
1047OP_80 ()
1048{
1049 unsigned int op0, op1, result, z, s, cy, ov, sat;
1050
1051 trace_input ("satsubr", OP_REG_REG, 0);
1052
1053 /* Compute the result. */
1054 op0 = State.regs[ OP[0] ];
1055 op1 = State.regs[ OP[1] ];
1056 result = op0 - op1;
1057
1058 /* Compute the condition codes. */
1059 z = (result == 0);
1060 s = (result & 0x80000000);
c5fbc25b
DD		 1061 cy = (op0 < op1);
1062 ov = ((op0 & 0x80000000) != (op1 & 0x80000000)
1063 && (op0 & 0x80000000) != (result & 0x80000000));
c906108c 1064 sat = ov;
c5fbc25b
DD		 1065
1066 /* Handle saturated results. */
1067 if (sat && s)
1068 {
1069 /* An overflow that results in a negative result implies that we
1070 became too positive. */
1071 result = 0x7fffffff;
1072 s = 0;
1073 }
1074 else if (sat)
1075 {
1076 /* Any other overflow must have thus been too negative. */
1077 result = 0x80000000;
1078 s = 1;
1079 z = 0;
1080 }
c906108c
SS		 1081
1082 /* Store the result and condition codes. */
1083 State.regs[OP[1]] = result;
1084 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1085 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1086 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1087 | (sat ? PSW_SAT : 0));
1088
c906108c
SS		 1089 trace_output (OP_REG_REG);
1090
1091 return 2;
1092}
1093
1094/* tst reg,reg */
1095int
1096OP_160 ()
1097{
1098 unsigned int op0, op1, result, z, s;
1099
1100 trace_input ("tst", OP_REG_REG_CMP, 0);
1101
1102 /* Compute the result. */
1103 op0 = State.regs[ OP[0] ];
1104 op1 = State.regs[ OP[1] ];
1105 result = op0 & op1;
1106
1107 /* Compute the condition codes. */
1108 z = (result == 0);
1109 s = (result & 0x80000000);
1110
1111 /* Store the condition codes. */
1112 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1113 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1114 trace_output (OP_REG_REG_CMP);
1115
1116 return 2;
1117}
1118
1119/* mov sign_extend(imm5), reg */
1120int
1121OP_200 ()
1122{
1123 int value = SEXT5 (OP[0]);
1124
1125 trace_input ("mov", OP_IMM_REG_MOVE, 0);
1126
1127 State.regs[ OP[1] ] = value;
1128
1129 trace_output (OP_IMM_REG_MOVE);
1130
1131 return 2;
1132}
1133
1134/* movhi imm16, reg, reg */
1135int
1136OP_640 ()
1137{
1138 trace_input ("movhi", OP_UIMM16_REG_REG, 16);
1139
1140 State.regs[ OP[1] ] = State.regs[ OP[0] ] + (OP[2] << 16);
1141
1142 trace_output (OP_UIMM16_REG_REG);
1143
1144 return 4;
1145}
1146
1147/* sar zero_extend(imm5),reg1 */
1148int
1149OP_2A0 ()
1150{
1151 unsigned int op0, op1, result, z, s, cy;
1152
1153 trace_input ("sar", OP_IMM_REG, 0);
1154 op0 = OP[0];
1155 op1 = State.regs[ OP[1] ];
1156 result = (signed)op1 >> op0;
1157
1158 /* Compute the condition codes. */
1159 z = (result == 0);
1160 s = (result & 0x80000000);
c5fbc25b 1161 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
c906108c
SS		 1162
1163 /* Store the result and condition codes. */
1164 State.regs[ OP[1] ] = result;
1165 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1166 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1167 | (cy ? PSW_CY : 0));
1168 trace_output (OP_IMM_REG);
1169
1170 return 2;
1171}
1172
1173/* sar reg1, reg2 */
1174int
1175OP_A007E0 ()
1176{
1177 unsigned int op0, op1, result, z, s, cy;
1178
1179 trace_input ("sar", OP_REG_REG, 0);
1180
1181 op0 = State.regs[ OP[0] ] & 0x1f;
1182 op1 = State.regs[ OP[1] ];
1183 result = (signed)op1 >> op0;
1184
1185 /* Compute the condition codes. */
1186 z = (result == 0);
1187 s = (result & 0x80000000);
c5fbc25b 1188 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
c906108c
SS		 1189
1190 /* Store the result and condition codes. */
1191 State.regs[OP[1]] = result;
1192 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1193 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1194 | (cy ? PSW_CY : 0));
1195 trace_output (OP_REG_REG);
1196
1197 return 4;
1198}
1199
1200/* shl zero_extend(imm5),reg1 */
1201int
1202OP_2C0 ()
1203{
1204 unsigned int op0, op1, result, z, s, cy;
1205
1206 trace_input ("shl", OP_IMM_REG, 0);
1207 op0 = OP[0];
1208 op1 = State.regs[ OP[1] ];
1209 result = op1 << op0;
1210
1211 /* Compute the condition codes. */
1212 z = (result == 0);
1213 s = (result & 0x80000000);
c5fbc25b 1214 cy = op0 ? (op1 & (1 << (32 - op0))) : 0;
c906108c
SS		 1215
1216 /* Store the result and condition codes. */
1217 State.regs[OP[1]] = result;
1218 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1219 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1220 | (cy ? PSW_CY : 0));
1221 trace_output (OP_IMM_REG);
1222
1223 return 2;
1224}
1225
1226/* shl reg1, reg2 */
1227int
1228OP_C007E0 ()
1229{
1230 unsigned int op0, op1, result, z, s, cy;
1231
1232 trace_input ("shl", OP_REG_REG, 0);
1233 op0 = State.regs[ OP[0] ] & 0x1f;
1234 op1 = State.regs[ OP[1] ];
1235 result = op1 << op0;
1236
1237 /* Compute the condition codes. */
1238 z = (result == 0);
1239 s = (result & 0x80000000);
c5fbc25b 1240 cy = op0 ? (op1 & (1 << (32 - op0))) : 0;
c906108c
SS		 1241
1242 /* Store the result and condition codes. */
1243 State.regs[OP[1]] = result;
1244 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1245 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1246 | (cy ? PSW_CY : 0));
1247 trace_output (OP_REG_REG);
1248
1249 return 4;
1250}
1251
1252/* shr zero_extend(imm5),reg1 */
1253int
1254OP_280 ()
1255{
1256 unsigned int op0, op1, result, z, s, cy;
1257
1258 trace_input ("shr", OP_IMM_REG, 0);
1259 op0 = OP[0];
1260 op1 = State.regs[ OP[1] ];
1261 result = op1 >> op0;
1262
1263 /* Compute the condition codes. */
1264 z = (result == 0);
1265 s = (result & 0x80000000);
c5fbc25b 1266 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
c906108c
SS		 1267
1268 /* Store the result and condition codes. */
1269 State.regs[OP[1]] = result;
1270 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1271 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1272 | (cy ? PSW_CY : 0));
1273 trace_output (OP_IMM_REG);
1274
1275 return 2;
1276}
1277
1278/* shr reg1, reg2 */
1279int
1280OP_8007E0 ()
1281{
1282 unsigned int op0, op1, result, z, s, cy;
1283
1284 trace_input ("shr", OP_REG_REG, 0);
1285 op0 = State.regs[ OP[0] ] & 0x1f;
1286 op1 = State.regs[ OP[1] ];
1287 result = op1 >> op0;
1288
1289 /* Compute the condition codes. */
1290 z = (result == 0);
1291 s = (result & 0x80000000);
c5fbc25b 1292 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
c906108c
SS		 1293
1294 /* Store the result and condition codes. */
1295 State.regs[OP[1]] = result;
1296 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1297 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1298 | (cy ? PSW_CY : 0));
1299 trace_output (OP_REG_REG);
1300
1301 return 4;
1302}
1303
1304/* or reg, reg */
1305int
1306OP_100 ()
1307{
1308 unsigned int op0, op1, result, z, s;
1309
1310 trace_input ("or", OP_REG_REG, 0);
1311
1312 /* Compute the result. */
1313 op0 = State.regs[ OP[0] ];
1314 op1 = State.regs[ OP[1] ];
1315 result = op0 | op1;
1316
1317 /* Compute the condition codes. */
1318 z = (result == 0);
1319 s = (result & 0x80000000);
1320
1321 /* Store the result and condition codes. */
1322 State.regs[OP[1]] = result;
1323 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1324 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1325 trace_output (OP_REG_REG);
1326
1327 return 2;
1328}
1329
1330/* ori zero_extend(imm16), reg, reg */
1331int
1332OP_680 ()
1333{
1334 unsigned int op0, op1, result, z, s;
1335
1336 trace_input ("ori", OP_UIMM16_REG_REG, 0);
1337 op0 = OP[2];
1338 op1 = State.regs[ OP[0] ];
1339 result = op0 | op1;
1340
1341 /* Compute the condition codes. */
1342 z = (result == 0);
1343 s = (result & 0x80000000);
1344
1345 /* Store the result and condition codes. */
1346 State.regs[OP[1]] = result;
1347 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1348 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1349 trace_output (OP_UIMM16_REG_REG);
1350
1351 return 4;
1352}
1353
1354/* and reg, reg */
1355int
1356OP_140 ()
1357{
1358 unsigned int op0, op1, result, z, s;
1359
1360 trace_input ("and", OP_REG_REG, 0);
1361
1362 /* Compute the result. */
1363 op0 = State.regs[ OP[0] ];
1364 op1 = State.regs[ OP[1] ];
1365 result = op0 & op1;
1366
1367 /* Compute the condition codes. */
1368 z = (result == 0);
1369 s = (result & 0x80000000);
1370
1371 /* Store the result and condition codes. */
1372 State.regs[OP[1]] = result;
1373 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1374 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1375 trace_output (OP_REG_REG);
1376
1377 return 2;
1378}
1379
1380/* andi zero_extend(imm16), reg, reg */
1381int
1382OP_6C0 ()
1383{
1384 unsigned int result, z;
1385
1386 trace_input ("andi", OP_UIMM16_REG_REG, 0);
1387
1388 result = OP[2] & State.regs[ OP[0] ];
1389
1390 /* Compute the condition codes. */
1391 z = (result == 0);
1392
1393 /* Store the result and condition codes. */
1394 State.regs[ OP[1] ] = result;
1395
1396 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1397 PSW |= (z ? PSW_Z : 0);
1398
1399 trace_output (OP_UIMM16_REG_REG);
1400
1401 return 4;
1402}
1403
1404/* xor reg, reg */
1405int
1406OP_120 ()
1407{
1408 unsigned int op0, op1, result, z, s;
1409
1410 trace_input ("xor", OP_REG_REG, 0);
1411
1412 /* Compute the result. */
1413 op0 = State.regs[ OP[0] ];
1414 op1 = State.regs[ OP[1] ];
1415 result = op0 ^ op1;
1416
1417 /* Compute the condition codes. */
1418 z = (result == 0);
1419 s = (result & 0x80000000);
1420
1421 /* Store the result and condition codes. */
1422 State.regs[OP[1]] = result;
1423 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1424 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1425 trace_output (OP_REG_REG);
1426
1427 return 2;
1428}
1429
1430/* xori zero_extend(imm16), reg, reg */
1431int
1432OP_6A0 ()
1433{
1434 unsigned int op0, op1, result, z, s;
1435
1436 trace_input ("xori", OP_UIMM16_REG_REG, 0);
1437 op0 = OP[2];
1438 op1 = State.regs[ OP[0] ];
1439 result = op0 ^ op1;
1440
1441 /* Compute the condition codes. */
1442 z = (result == 0);
1443 s = (result & 0x80000000);
1444
1445 /* Store the result and condition codes. */
1446 State.regs[OP[1]] = result;
1447 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1448 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1449 trace_output (OP_UIMM16_REG_REG);
1450
1451 return 4;
1452}
1453
1454/* not reg1, reg2 */
1455int
1456OP_20 ()
1457{
1458 unsigned int op0, result, z, s;
1459
1460 trace_input ("not", OP_REG_REG_MOVE, 0);
1461 /* Compute the result. */
1462 op0 = State.regs[ OP[0] ];
1463 result = ~op0;
1464
1465 /* Compute the condition codes. */
1466 z = (result == 0);
1467 s = (result & 0x80000000);
1468
1469 /* Store the result and condition codes. */
1470 State.regs[OP[1]] = result;
1471 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1472 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1473 trace_output (OP_REG_REG_MOVE);
1474
1475 return 2;
1476}
1477
1478/* set1 */
1479int
1480OP_7C0 ()
1481{
1482 unsigned int op0, op1, op2;
1483 int temp;
1484
1485 trace_input ("set1", OP_BIT, 0);
1486 op0 = State.regs[ OP[0] ];
1487 op1 = OP[1] & 0x7;
1488 temp = EXTEND16 (OP[2]);
1489 op2 = temp;
1490 temp = load_mem (op0 + op2, 1);
1491 PSW &= ~PSW_Z;
1492 if ((temp & (1 << op1)) == 0)
1493 PSW |= PSW_Z;
1494 temp |= (1 << op1);
1495 store_mem (op0 + op2, 1, temp);
1496 trace_output (OP_BIT);
1497
1498 return 4;
1499}
1500
1501/* not1 */
1502int
1503OP_47C0 ()
1504{
1505 unsigned int op0, op1, op2;
1506 int temp;
1507
1508 trace_input ("not1", OP_BIT, 0);
1509 op0 = State.regs[ OP[0] ];
1510 op1 = OP[1] & 0x7;
1511 temp = EXTEND16 (OP[2]);
1512 op2 = temp;
1513 temp = load_mem (op0 + op2, 1);
1514 PSW &= ~PSW_Z;
1515 if ((temp & (1 << op1)) == 0)
1516 PSW |= PSW_Z;
1517 temp ^= (1 << op1);
1518 store_mem (op0 + op2, 1, temp);
1519 trace_output (OP_BIT);
1520
1521 return 4;
1522}
1523
1524/* clr1 */
1525int
1526OP_87C0 ()
1527{
1528 unsigned int op0, op1, op2;
1529 int temp;
1530
1531 trace_input ("clr1", OP_BIT, 0);
1532 op0 = State.regs[ OP[0] ];
1533 op1 = OP[1] & 0x7;
1534 temp = EXTEND16 (OP[2]);
1535 op2 = temp;
1536 temp = load_mem (op0 + op2, 1);
1537 PSW &= ~PSW_Z;
1538 if ((temp & (1 << op1)) == 0)
1539 PSW |= PSW_Z;
1540 temp &= ~(1 << op1);
1541 store_mem (op0 + op2, 1, temp);
1542 trace_output (OP_BIT);
1543
1544 return 4;
1545}
1546
1547/* tst1 */
1548int
1549OP_C7C0 ()
1550{
1551 unsigned int op0, op1, op2;
1552 int temp;
1553
1554 trace_input ("tst1", OP_BIT, 0);
1555 op0 = State.regs[ OP[0] ];
1556 op1 = OP[1] & 0x7;
1557 temp = EXTEND16 (OP[2]);
1558 op2 = temp;
1559 temp = load_mem (op0 + op2, 1);
1560 PSW &= ~PSW_Z;
1561 if ((temp & (1 << op1)) == 0)
1562 PSW |= PSW_Z;
1563 trace_output (OP_BIT);
1564
1565 return 4;
1566}
1567
1568/* di */
1569int
1570OP_16007E0 ()
1571{
1572 trace_input ("di", OP_NONE, 0);
1573 PSW |= PSW_ID;
1574 trace_output (OP_NONE);
1575
1576 return 4;
1577}
1578
1579/* ei */
1580int
1581OP_16087E0 ()
1582{
1583 trace_input ("ei", OP_NONE, 0);
1584 PSW &= ~PSW_ID;
1585 trace_output (OP_NONE);
1586
1587 return 4;
1588}
1589
1590/* halt */
1591int
1592OP_12007E0 ()
1593{
1594 trace_input ("halt", OP_NONE, 0);
1595 /* FIXME this should put processor into a mode where NMI still handled */
1596 trace_output (OP_NONE);
1597 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1598 sim_stopped, SIM_SIGTRAP);
1599 return 0;
1600}
1601
1602/* trap */
1603int
1604OP_10007E0 ()
1605{
1606 trace_input ("trap", OP_TRAP, 0);
1607 trace_output (OP_TRAP);
1608
1609 /* Trap 31 is used for simulating OS I/O functions */
1610
1611 if (OP[0] == 31)
1612 {
1613 int save_errno = errno;
1614 errno = 0;
1615
1616/* Registers passed to trap 0 */
1617
1618#define FUNC State.regs[6] /* function number, return value */
1619#define PARM1 State.regs[7] /* optional parm 1 */
1620#define PARM2 State.regs[8] /* optional parm 2 */
1621#define PARM3 State.regs[9] /* optional parm 3 */
1622
1623/* Registers set by trap 0 */
1624
1625#define RETVAL State.regs[10] /* return value */
1626#define RETERR State.regs[11] /* return error code */
1627
1628/* Turn a pointer in a register into a pointer into real memory. */
1629
1630#define MEMPTR(x) (map (x))
1631
d0f0baa2
KB		 1632 RETERR = 0;
1633
c906108c
SS		 1634 switch (FUNC)
1635 {
1636
1637#ifdef HAVE_FORK
1638#ifdef TARGET_SYS_fork
1639 case TARGET_SYS_fork:
1640 RETVAL = fork ();
d0f0baa2 1641 RETERR = errno;
c906108c
SS		 1642 break;
1643#endif
1644#endif
1645
1646#ifdef HAVE_EXECVE
1647#ifdef TARGET_SYS_execv
1648 case TARGET_SYS_execve:
1649 {
1650 char *path = fetch_str (simulator, PARM1);
1651 char **argv = fetch_argv (simulator, PARM2);
1652 char **envp = fetch_argv (simulator, PARM3);
1653 RETVAL = execve (path, argv, envp);
d79fe0d6 1654 free (path);
c906108c
SS		 1655 freeargv (argv);
1656 freeargv (envp);
d0f0baa2 1657 RETERR = errno;
c906108c
SS		 1658 break;
1659 }
1660#endif
1661#endif
1662
1663#if HAVE_EXECV
1664#ifdef TARGET_SYS_execv
1665 case TARGET_SYS_execv:
1666 {
1667 char *path = fetch_str (simulator, PARM1);
1668 char **argv = fetch_argv (simulator, PARM2);
1669 RETVAL = execv (path, argv);
d79fe0d6 1670 free (path);
c906108c 1671 freeargv (argv);
d0f0baa2 1672 RETERR = errno;
c906108c
SS		 1673 break;
1674 }
1675#endif
1676#endif
1677
1678#if 0
1679#ifdef TARGET_SYS_pipe
1680 case TARGET_SYS_pipe:
1681 {
1682 reg_t buf;
1683 int host_fd[2];
1684
1685 buf = PARM1;
1686 RETVAL = pipe (host_fd);
1687 SW (buf, host_fd[0]);
1688 buf += sizeof(uint16);
1689 SW (buf, host_fd[1]);
d0f0baa2 1690 RETERR = errno;
c906108c
SS		 1691 }
1692 break;
1693#endif
1694#endif
1695
1696#if 0
1697#ifdef TARGET_SYS_wait
1698 case TARGET_SYS_wait:
1699 {
1700 int status;
1701
1702 RETVAL = wait (&status);
1703 SW (PARM1, status);
d0f0baa2 1704 RETERR = errno;
c906108c
SS		 1705 }
1706 break;
1707#endif
1708#endif
1709
1710#ifdef TARGET_SYS_read
1711 case TARGET_SYS_read:
1712 {
1713 char *buf = zalloc (PARM3);
1714 RETVAL = sim_io_read (simulator, PARM1, buf, PARM3);
1715 sim_write (simulator, PARM2, buf, PARM3);
d79fe0d6 1716 free (buf);
d0f0baa2
KB		 1717 if ((int) RETVAL < 0)
1718 RETERR = sim_io_get_errno (simulator);
c906108c
SS		 1719 break;
1720 }
1721#endif
1722
1723#ifdef TARGET_SYS_write
1724 case TARGET_SYS_write:
1725 {
1726 char *buf = zalloc (PARM3);
1727 sim_read (simulator, PARM2, buf, PARM3);
1728 if (PARM1 == 1)
1729 RETVAL = sim_io_write_stdout (simulator, buf, PARM3);
1730 else
1731 RETVAL = sim_io_write (simulator, PARM1, buf, PARM3);
d79fe0d6 1732 free (buf);
d0f0baa2
KB		 1733 if ((int) RETVAL < 0)
1734 RETERR = sim_io_get_errno (simulator);
c906108c
SS		 1735 break;
1736 }
1737#endif
1738
1739#ifdef TARGET_SYS_lseek
1740 case TARGET_SYS_lseek:
1741 RETVAL = sim_io_lseek (simulator, PARM1, PARM2, PARM3);
d0f0baa2
KB		 1742 if ((int) RETVAL < 0)
1743 RETERR = sim_io_get_errno (simulator);
c906108c
SS		 1744 break;
1745#endif
1746
1747#ifdef TARGET_SYS_close
1748 case TARGET_SYS_close:
1749 RETVAL = sim_io_close (simulator, PARM1);
d0f0baa2
KB		 1750 if ((int) RETVAL < 0)
1751 RETERR = sim_io_get_errno (simulator);
c906108c
SS		 1752 break;
1753#endif
1754
1755#ifdef TARGET_SYS_open
1756 case TARGET_SYS_open:
1757 {
1758 char *buf = fetch_str (simulator, PARM1);
1759 RETVAL = sim_io_open (simulator, buf, PARM2);
d79fe0d6 1760 free (buf);
d0f0baa2
KB		 1761 if ((int) RETVAL < 0)
1762 RETERR = sim_io_get_errno (simulator);
c906108c
SS		 1763 break;
1764 }
1765#endif
1766
1767#ifdef TARGET_SYS_exit
1768 case TARGET_SYS_exit:
1769 if ((PARM1 & 0xffff0000) == 0xdead0000 && (PARM1 & 0xffff) != 0)
1770 /* get signal encoded by kill */
1771 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1772 sim_signalled, PARM1 & 0xffff);
1773 else if (PARM1 == 0xdead)
1774 /* old libraries */
1775 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1776 sim_stopped, SIM_SIGABRT);
1777 else
1778 /* PARM1 has exit status */
1779 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1780 sim_exited, PARM1);
1781 break;
1782#endif
1783
c906108c
SS		 1784#ifdef TARGET_SYS_stat
1785 case TARGET_SYS_stat: /* added at hmsi */
1786 /* stat system call */
1787 {
1788 struct stat host_stat;
1789 reg_t buf;
1790 char *path = fetch_str (simulator, PARM1);
1791
d0f0baa2 1792 RETVAL = sim_io_stat (simulator, path, &host_stat);
c906108c 1793
d79fe0d6 1794 free (path);
c906108c
SS		 1795 buf = PARM2;
1796
1797 /* Just wild-assed guesses. */
1798 store_mem (buf, 2, host_stat.st_dev);
1799 store_mem (buf + 2, 2, host_stat.st_ino);
1800 store_mem (buf + 4, 4, host_stat.st_mode);
1801 store_mem (buf + 8, 2, host_stat.st_nlink);
1802 store_mem (buf + 10, 2, host_stat.st_uid);
1803 store_mem (buf + 12, 2, host_stat.st_gid);
1804 store_mem (buf + 14, 2, host_stat.st_rdev);
1805 store_mem (buf + 16, 4, host_stat.st_size);
1806 store_mem (buf + 20, 4, host_stat.st_atime);
1807 store_mem (buf + 28, 4, host_stat.st_mtime);
1808 store_mem (buf + 36, 4, host_stat.st_ctime);
d0f0baa2
KB		 1809
1810 if ((int) RETVAL < 0)
1811 RETERR = sim_io_get_errno (simulator);
1812 }
1813 break;
1814#endif
1815
1816#ifdef TARGET_SYS_fstat
1817 case TARGET_SYS_fstat:
1818 /* fstat system call */
1819 {
1820 struct stat host_stat;
1821 reg_t buf;
1822
1823 RETVAL = sim_io_fstat (simulator, PARM1, &host_stat);
1824
1825 buf = PARM2;
1826
1827 /* Just wild-assed guesses. */
1828 store_mem (buf, 2, host_stat.st_dev);
1829 store_mem (buf + 2, 2, host_stat.st_ino);
1830 store_mem (buf + 4, 4, host_stat.st_mode);
1831 store_mem (buf + 8, 2, host_stat.st_nlink);
1832 store_mem (buf + 10, 2, host_stat.st_uid);
1833 store_mem (buf + 12, 2, host_stat.st_gid);
1834 store_mem (buf + 14, 2, host_stat.st_rdev);
1835 store_mem (buf + 16, 4, host_stat.st_size);
1836 store_mem (buf + 20, 4, host_stat.st_atime);
1837 store_mem (buf + 28, 4, host_stat.st_mtime);
1838 store_mem (buf + 36, 4, host_stat.st_ctime);
1839
1840 if ((int) RETVAL < 0)
1841 RETERR = sim_io_get_errno (simulator);
c906108c
SS		 1842 }
1843 break;
1844#endif
d0f0baa2
KB		 1845
1846#ifdef TARGET_SYS_rename
1847 case TARGET_SYS_rename:
1848 {
1849 char *oldpath = fetch_str (simulator, PARM1);
1850 char *newpath = fetch_str (simulator, PARM2);
1851 RETVAL = sim_io_rename (simulator, oldpath, newpath);
1852 free (oldpath);
1853 free (newpath);
1854 if ((int) RETVAL < 0)
1855 RETERR = sim_io_get_errno (simulator);
1856 }
1857 break;
1858#endif
1859
1860#ifdef TARGET_SYS_unlink
1861 case TARGET_SYS_unlink:
1862 {
1863 char *path = fetch_str (simulator, PARM1);
1864 RETVAL = sim_io_unlink (simulator, path);
1865 free (path);
1866 if ((int) RETVAL < 0)
1867 RETERR = sim_io_get_errno (simulator);
1868 }
1869 break;
c906108c
SS		 1870#endif
1871
1872#ifdef HAVE_CHOWN
1873#ifdef TARGET_SYS_chown
1874 case TARGET_SYS_chown:
1875 {
1876 char *path = fetch_str (simulator, PARM1);
1877 RETVAL = chown (path, PARM2, PARM3);
d79fe0d6 1878 free (path);
d0f0baa2 1879 RETERR = errno;
c906108c
SS		 1880 }
1881 break;
1882#endif
1883#endif
1884
1885#if HAVE_CHMOD
1886#ifdef TARGET_SYS_chmod
1887 case TARGET_SYS_chmod:
1888 {
1889 char *path = fetch_str (simulator, PARM1);
1890 RETVAL = chmod (path, PARM2);
d79fe0d6 1891 free (path);
d0f0baa2 1892 RETERR = errno;
c906108c
SS		 1893 }
1894 break;
1895#endif
1896#endif
1897
1898#ifdef TARGET_SYS_time
1899#if HAVE_TIME
1900 case TARGET_SYS_time:
1901 {
1902 time_t now;
1903 RETVAL = time (&now);
1904 store_mem (PARM1, 4, now);
d0f0baa2 1905 RETERR = errno;
c906108c
SS		 1906 }
1907 break;
1908#endif
1909#endif
1910
1911#if !defined(__GO32__) && !defined(_WIN32)
1912#ifdef TARGET_SYS_times
1913 case TARGET_SYS_times:
1914 {
1915 struct tms tms;
1916 RETVAL = times (&tms);
1917 store_mem (PARM1, 4, tms.tms_utime);
1918 store_mem (PARM1 + 4, 4, tms.tms_stime);
1919 store_mem (PARM1 + 8, 4, tms.tms_cutime);
1920 store_mem (PARM1 + 12, 4, tms.tms_cstime);
d0f0baa2 1921 reterr = errno;
c906108c
SS		 1922 break;
1923 }
1924#endif
1925#endif
1926
1927#ifdef TARGET_SYS_gettimeofday
1928#if !defined(__GO32__) && !defined(_WIN32)
1929 case TARGET_SYS_gettimeofday:
1930 {
1931 struct timeval t;
1932 struct timezone tz;
1933 RETVAL = gettimeofday (&t, &tz);
1934 store_mem (PARM1, 4, t.tv_sec);
1935 store_mem (PARM1 + 4, 4, t.tv_usec);
1936 store_mem (PARM2, 4, tz.tz_minuteswest);
1937 store_mem (PARM2 + 4, 4, tz.tz_dsttime);
d0f0baa2 1938 RETERR = errno;
c906108c
SS		 1939 break;
1940 }
1941#endif
1942#endif
1943
1944#ifdef TARGET_SYS_utime
1945#if HAVE_UTIME
1946 case TARGET_SYS_utime:
1947 {
1948 /* Cast the second argument to void *, to avoid type mismatch
1949 if a prototype is present. */
1950 sim_io_error (simulator, "Utime not supported");
1951 /* RETVAL = utime (path, (void *) MEMPTR (PARM2)); */
1952 }
1953 break;
1954#endif
1955#endif
1956
1957 default:
1958 abort ();
1959 }
c906108c
SS		 1960 errno = save_errno;
1961
1962 return 4;
1963 }
1964 else
1965 { /* Trap 0 -> 30 */
1966 EIPC = PC + 4;
1967 EIPSW = PSW;
1968 /* Mask out EICC */
1969 ECR &= 0xffff0000;
1970 ECR |= 0x40 + OP[0];
1971 /* Flag that we are now doing exception processing. */
1972 PSW |= PSW_EP | PSW_ID;
2e8162ce 1973 PC = (OP[0] < 0x10) ? 0x40 : 0x50;
c906108c
SS		 1974
1975 return 0;
1976 }
1977}
1978
1979/* tst1 reg2, [reg1] */
1980int
1981OP_E607E0 (void)
1982{
1983 int temp;
1984
1985 trace_input ("tst1", OP_BIT, 1);
1986
1987 temp = load_mem (State.regs[ OP[0] ], 1);
1988
1989 PSW &= ~PSW_Z;
30458d39 1990 if ((temp & (1 << (State.regs[ OP[1] ] & 0x7))) == 0)
c906108c
SS		 1991 PSW |= PSW_Z;
1992
1993 trace_output (OP_BIT);
1994
1995 return 4;
1996}
1997
1998/* mulu reg1, reg2, reg3 */
1999int
2000OP_22207E0 (void)
2001{
2002 trace_input ("mulu", OP_REG_REG_REG, 0);
2003
0da2b665 2004 Multiply64 (0, State.regs[ OP[0] ]);
c906108c
SS		 2005
2006 trace_output (OP_REG_REG_REG);
2007
2008 return 4;
2009}
2010
2011#define BIT_CHANGE_OP( name, binop ) \
2012 unsigned int bit; \
2013 unsigned int temp; \
2014 \
2015 trace_input (name, OP_BIT_CHANGE, 0); \
2016 \
30458d39 2017 bit = 1 << (State.regs[ OP[1] ] & 0x7); \
c906108c
SS		 2018 temp = load_mem (State.regs[ OP[0] ], 1); \
2019 \
2020 PSW &= ~PSW_Z; \
2021 if ((temp & bit) == 0) \
2022 PSW |= PSW_Z; \
2023 temp binop bit; \
2024 \
2025 store_mem (State.regs[ OP[0] ], 1, temp); \
2026 \
2027 trace_output (OP_BIT_CHANGE); \
2028 \
2029 return 4;
2030
2031/* clr1 reg2, [reg1] */
2032int
2033OP_E407E0 (void)
2034{
2035 BIT_CHANGE_OP ("clr1", &= ~ );
2036}
2037
2038/* not1 reg2, [reg1] */
2039int
2040OP_E207E0 (void)
2041{
2042 BIT_CHANGE_OP ("not1", ^= );
2043}
2044
2045/* set1 */
2046int
2047OP_E007E0 (void)
2048{
2049 BIT_CHANGE_OP ("set1", |= );
2050}
2051
2052/* sasf */
2053int
2054OP_20007E0 (void)
2055{
2056 trace_input ("sasf", OP_EX1, 0);
2057
2058 State.regs[ OP[1] ] = (State.regs[ OP[1] ] << 1) | condition_met (OP[0]);
2059
2060 trace_output (OP_EX1);
2061
2062 return 4;
2063}
2064
2065/* This function is courtesy of Sugimoto at NEC, via Seow Tan
2066 (Soew_Tan@el.nec.com) */
2067void
2068divun
2069(
2070 unsigned int N,
2071 unsigned long int als,
2072 unsigned long int sfi,
2073 unsigned32 /*unsigned long int*/ * quotient_ptr,
2074 unsigned32 /*unsigned long int*/ * remainder_ptr,
0da2b665 2075 int * overflow_ptr
c906108c
SS		 2076)
2077{
2078 unsigned long ald = sfi >> (N - 1);
2079 unsigned long alo = als;
2080 unsigned int Q = 1;
2081 unsigned int C;
2082 unsigned int S = 0;
2083 unsigned int i;
2084 unsigned int R1 = 1;
2085 unsigned int DBZ = (als == 0) ? 1 : 0;
2086 unsigned long alt = Q ? ~als : als;
2087
2088 /* 1st Loop */
2089 alo = ald + alt + Q;
2090 C = (((alt >> 31) & (ald >> 31))
2091 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2092 C = C ^ Q;
2093 Q = ~(C ^ S) & 1;
2094 R1 = (alo == 0) ? 0 : (R1 & Q);
2095 if ((S ^ (alo>>31)) && !C)
2096 {
2097 DBZ = 1;
2098 }
2099 S = alo >> 31;
2100 sfi = (sfi << (32-N+1)) | Q;
2101 ald = (alo << 1) | (sfi >> 31);
2102
2103 /* 2nd - N-1th Loop */
2104 for (i = 2; i < N; i++)
2105 {
2106 alt = Q ? ~als : als;
2107 alo = ald + alt + Q;
2108 C = (((alt >> 31) & (ald >> 31))
2109 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2110 C = C ^ Q;
2111 Q = ~(C ^ S) & 1;
2112 R1 = (alo == 0) ? 0 : (R1 & Q);
2113 if ((S ^ (alo>>31)) && !C && !DBZ)
2114 {
2115 DBZ = 1;
2116 }
2117 S = alo >> 31;
2118 sfi = (sfi << 1) | Q;
2119 ald = (alo << 1) | (sfi >> 31);
2120 }
2121
2122 /* Nth Loop */
2123 alt = Q ? ~als : als;
2124 alo = ald + alt + Q;
2125 C = (((alt >> 31) & (ald >> 31))
2126 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2127 C = C ^ Q;
2128 Q = ~(C ^ S) & 1;
2129 R1 = (alo == 0) ? 0 : (R1 & Q);
2130 if ((S ^ (alo>>31)) && !C)
2131 {
2132 DBZ = 1;
2133 }
2134
2135 * quotient_ptr = (sfi << 1) | Q;
2136 * remainder_ptr = Q ? alo : (alo + als);
2137 * overflow_ptr = DBZ | R1;
2138}
2139
2140/* This function is courtesy of Sugimoto at NEC, via Seow Tan (Soew_Tan@el.nec.com) */
2141void
2142divn
2143(
2144 unsigned int N,
2145 unsigned long int als,
2146 unsigned long int sfi,
2147 signed32 /*signed long int*/ * quotient_ptr,
2148 signed32 /*signed long int*/ * remainder_ptr,
0da2b665 2149 int * overflow_ptr
c906108c
SS		 2150)
2151{
2152 unsigned long ald = (signed long) sfi >> (N - 1);
2153 unsigned long alo = als;
2154 unsigned int SS = als >> 31;
2155 unsigned int SD = sfi >> 31;
2156 unsigned int R1 = 1;
2157 unsigned int OV;
2158 unsigned int DBZ = als == 0 ? 1 : 0;
2159 unsigned int Q = ~(SS ^ SD) & 1;
2160 unsigned int C;
2161 unsigned int S;
2162 unsigned int i;
2163 unsigned long alt = Q ? ~als : als;
2164
2165
2166 /* 1st Loop */
2167
2168 alo = ald + alt + Q;
2169 C = (((alt >> 31) & (ald >> 31))
2170 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2171 Q = C ^ SS;
2172 R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2173 S = alo >> 31;
2174 sfi = (sfi << (32-N+1)) | Q;
2175 ald = (alo << 1) | (sfi >> 31);
2176 if ((alo >> 31) ^ (ald >> 31))
2177 {
2178 DBZ = 1;
2179 }
2180
2181 /* 2nd - N-1th Loop */
2182
2183 for (i = 2; i < N; i++)
2184 {
2185 alt = Q ? ~als : als;
2186 alo = ald + alt + Q;
2187 C = (((alt >> 31) & (ald >> 31))
2188 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2189 Q = C ^ SS;
2190 R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2191 S = alo >> 31;
2192 sfi = (sfi << 1) | Q;
2193 ald = (alo << 1) | (sfi >> 31);
2194 if ((alo >> 31) ^ (ald >> 31))
2195 {
2196 DBZ = 1;
2197 }
2198 }
2199
2200 /* Nth Loop */
2201 alt = Q ? ~als : als;
2202 alo = ald + alt + Q;
2203 C = (((alt >> 31) & (ald >> 31))
2204 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2205 Q = C ^ SS;
2206 R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2207 sfi = (sfi << (32-N+1));
2208 ald = alo;
2209
2210 /* End */
2211 if (alo != 0)
2212 {
2213 alt = Q ? ~als : als;
2214 alo = ald + alt + Q;
2215 }
2216 R1 = R1 & ((~alo >> 31) ^ SD);
2217 if ((alo != 0) && ((Q ^ (SS ^ SD)) ^ R1)) alo = ald;
2218 if (N != 32)
2219 ald = sfi = (long) ((sfi >> 1) | (SS ^ SD) << 31) >> (32-N-1) | Q;
2220 else
2221 ald = sfi = sfi | Q;
2222
2223 OV = DBZ | ((alo == 0) ? 0 : R1);
2224
2225 * remainder_ptr = alo;
2226
2227 /* Adj */
2228 if (((alo != 0) && ((SS ^ SD) ^ R1))
2229 || ((alo == 0) && (SS ^ R1)))
2230 alo = ald + 1;
2231 else
2232 alo = ald;
2233
2234 OV = (DBZ | R1) ? OV : ((alo >> 31) & (~ald >> 31));
2235
2236 * quotient_ptr = alo;
2237 * overflow_ptr = OV;
2238}
2239
2240/* sdivun imm5, reg1, reg2, reg3 */
2241int
2242OP_1C207E0 (void)
2243{
2244 unsigned32 /*unsigned long int*/ quotient;
2245 unsigned32 /*unsigned long int*/ remainder;
2246 unsigned long int divide_by;
2247 unsigned long int divide_this;
0da2b665 2248 int overflow = 0;
c906108c
SS		 2249 unsigned int imm5;
2250
2251 trace_input ("sdivun", OP_IMM_REG_REG_REG, 0);
2252
2253 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2254
2255 divide_by = State.regs[ OP[0] ];
2256 divide_this = State.regs[ OP[1] ] << imm5;
2257
2258 divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2259
2260 State.regs[ OP[1] ] = quotient;
2261 State.regs[ OP[2] >> 11 ] = remainder;
2262
2263 /* Set condition codes. */
2264 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2265
2266 if (overflow) PSW |= PSW_OV;
2267 if (quotient == 0) PSW |= PSW_Z;
2268 if (quotient & 0x80000000) PSW |= PSW_S;
2269
2270 trace_output (OP_IMM_REG_REG_REG);
2271
2272 return 4;
2273}
2274
2275/* sdivn imm5, reg1, reg2, reg3 */
2276int
2277OP_1C007E0 (void)
2278{
2279 signed32 /*signed long int*/ quotient;
2280 signed32 /*signed long int*/ remainder;
2281 signed long int divide_by;
2282 signed long int divide_this;
0da2b665 2283 int overflow = 0;
c906108c
SS		 2284 unsigned int imm5;
2285
2286 trace_input ("sdivn", OP_IMM_REG_REG_REG, 0);
2287
2288 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2289
98e460c3
DD		 2290 divide_by = (signed32) State.regs[ OP[0] ];
2291 divide_this = (signed32) (State.regs[ OP[1] ] << imm5);
c906108c
SS		 2292
2293 divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2294
2295 State.regs[ OP[1] ] = quotient;
2296 State.regs[ OP[2] >> 11 ] = remainder;
2297
2298 /* Set condition codes. */
2299 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2300
2301 if (overflow) PSW |= PSW_OV;
2302 if (quotient == 0) PSW |= PSW_Z;
2303 if (quotient < 0) PSW |= PSW_S;
2304
2305 trace_output (OP_IMM_REG_REG_REG);
2306
2307 return 4;
2308}
2309
2310/* sdivhun imm5, reg1, reg2, reg3 */
2311int
2312OP_18207E0 (void)
2313{
2314 unsigned32 /*unsigned long int*/ quotient;
2315 unsigned32 /*unsigned long int*/ remainder;
2316 unsigned long int divide_by;
2317 unsigned long int divide_this;
0da2b665 2318 int overflow = 0;
c906108c
SS		 2319 unsigned int imm5;
2320
2321 trace_input ("sdivhun", OP_IMM_REG_REG_REG, 0);
2322
2323 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2324
2325 divide_by = State.regs[ OP[0] ] & 0xffff;
2326 divide_this = State.regs[ OP[1] ] << imm5;
2327
2328 divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2329
2330 State.regs[ OP[1] ] = quotient;
2331 State.regs[ OP[2] >> 11 ] = remainder;
2332
2333 /* Set condition codes. */
2334 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2335
2336 if (overflow) PSW |= PSW_OV;
2337 if (quotient == 0) PSW |= PSW_Z;
2338 if (quotient & 0x80000000) PSW |= PSW_S;
2339
2340 trace_output (OP_IMM_REG_REG_REG);
2341
2342 return 4;
2343}
2344
2345/* sdivhn imm5, reg1, reg2, reg3 */
2346int
2347OP_18007E0 (void)
2348{
2349 signed32 /*signed long int*/ quotient;
2350 signed32 /*signed long int*/ remainder;
2351 signed long int divide_by;
2352 signed long int divide_this;
0da2b665 2353 int overflow = 0;
c906108c
SS		 2354 unsigned int imm5;
2355
2356 trace_input ("sdivhn", OP_IMM_REG_REG_REG, 0);
2357
2358 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2359
2360 divide_by = EXTEND16 (State.regs[ OP[0] ]);
98e460c3 2361 divide_this = (signed32) (State.regs[ OP[1] ] << imm5);
c906108c
SS		 2362
2363 divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2364
2365 State.regs[ OP[1] ] = quotient;
2366 State.regs[ OP[2] >> 11 ] = remainder;
2367
2368 /* Set condition codes. */
2369 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2370
2371 if (overflow) PSW |= PSW_OV;
2372 if (quotient == 0) PSW |= PSW_Z;
2373 if (quotient < 0) PSW |= PSW_S;
2374
2375 trace_output (OP_IMM_REG_REG_REG);
2376
2377 return 4;
2378}
2379
2380/* divu reg1, reg2, reg3 */
2381int
2382OP_2C207E0 (void)
2383{
2384 unsigned long int quotient;
2385 unsigned long int remainder;
2386 unsigned long int divide_by;
2387 unsigned long int divide_this;
0da2b665 2388 int overflow = 0;
c906108c
SS		 2389
2390 trace_input ("divu", OP_REG_REG_REG, 0);
2391
2392 /* Compute the result. */
2393
2394 divide_by = State.regs[ OP[0] ];
2395 divide_this = State.regs[ OP[1] ];
2396
2397 if (divide_by == 0)
2398 {
c5fbc25b 2399 PSW |= PSW_OV;
c906108c 2400 }
c5fbc25b
DD		 2401 else
2402 {
2403 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2404 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
c906108c 2405
c5fbc25b
DD		 2406 /* Set condition codes. */
2407 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
c906108c 2408
c5fbc25b
DD		 2409 if (overflow) PSW |= PSW_OV;
2410 if (quotient == 0) PSW |= PSW_Z;
2411 if (quotient & 0x80000000) PSW |= PSW_S;
2412 }
c906108c
SS		 2413
2414 trace_output (OP_REG_REG_REG);
2415
2416 return 4;
2417}
2418
2419/* div reg1, reg2, reg3 */
2420int
2421OP_2C007E0 (void)
2422{
2423 signed long int quotient;
2424 signed long int remainder;
2425 signed long int divide_by;
2426 signed long int divide_this;
c906108c
SS		 2427
2428 trace_input ("div", OP_REG_REG_REG, 0);
2429
2430 /* Compute the result. */
2431
98e460c3 2432 divide_by = (signed32) State.regs[ OP[0] ];
c906108c
SS		 2433 divide_this = State.regs[ OP[1] ];
2434
c5fbc25b 2435 if (divide_by == 0)
c906108c 2436 {
c5fbc25b 2437 PSW |= PSW_OV;
c906108c 2438 }
98e460c3 2439 else if (divide_by == -1 && divide_this == (1L << 31))
c5fbc25b
DD		 2440 {
2441 PSW &= ~PSW_Z;
2442 PSW |= PSW_OV | PSW_S;
2443 State.regs[ OP[1] ] = (1 << 31);
2444 State.regs[ OP[2] >> 11 ] = 0;
2445 }
2446 else
2447 {
98e460c3 2448 divide_this = (signed32) divide_this;
c5fbc25b
DD		 2449 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2450 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
98e460c3 2451
c5fbc25b
DD		 2452 /* Set condition codes. */
2453 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
c906108c 2454
c5fbc25b
DD		 2455 if (quotient == 0) PSW |= PSW_Z;
2456 if (quotient < 0) PSW |= PSW_S;
2457 }
c906108c
SS		 2458
2459 trace_output (OP_REG_REG_REG);
2460
2461 return 4;
2462}
2463
2464/* divhu reg1, reg2, reg3 */
2465int
2466OP_28207E0 (void)
2467{
2468 unsigned long int quotient;
2469 unsigned long int remainder;
2470 unsigned long int divide_by;
2471 unsigned long int divide_this;
0da2b665 2472 int overflow = 0;
c906108c
SS		 2473
2474 trace_input ("divhu", OP_REG_REG_REG, 0);
2475
2476 /* Compute the result. */
2477
2478 divide_by = State.regs[ OP[0] ] & 0xffff;
2479 divide_this = State.regs[ OP[1] ];
2480
2481 if (divide_by == 0)
2482 {
c5fbc25b 2483 PSW |= PSW_OV;
c906108c 2484 }
c5fbc25b
DD		 2485 else
2486 {
2487 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2488 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
c906108c 2489
c5fbc25b
DD		 2490 /* Set condition codes. */
2491 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
c906108c 2492
c5fbc25b
DD		 2493 if (overflow) PSW |= PSW_OV;
2494 if (quotient == 0) PSW |= PSW_Z;
2495 if (quotient & 0x80000000) PSW |= PSW_S;
2496 }
c906108c
SS		 2497
2498 trace_output (OP_REG_REG_REG);
2499
2500 return 4;
2501}
2502
2503/* divh reg1, reg2, reg3 */
2504int
2505OP_28007E0 (void)
2506{
2507 signed long int quotient;
2508 signed long int remainder;
2509 signed long int divide_by;
2510 signed long int divide_this;
0da2b665 2511 int overflow = 0;
c906108c
SS		 2512
2513 trace_input ("divh", OP_REG_REG_REG, 0);
2514
2515 /* Compute the result. */
2516
c5fbc25b
DD		 2517 divide_by = EXTEND16 (State.regs[ OP[0] ]);
2518 divide_this = State.regs[ OP[1] ];
c906108c 2519
c5fbc25b
DD		 2520 if (divide_by == 0)
2521 {
2522 PSW |= PSW_OV;
2523 }
98e460c3 2524 else if (divide_by == -1 && divide_this == (1L << 31))
c906108c 2525 {
c5fbc25b
DD		 2526 PSW &= ~PSW_Z;
2527 PSW |= PSW_OV | PSW_S;
2528 State.regs[ OP[1] ] = (1 << 31);
2529 State.regs[ OP[2] >> 11 ] = 0;
c906108c 2530 }
c5fbc25b
DD		 2531 else
2532 {
98e460c3 2533 divide_this = (signed32) divide_this;
c5fbc25b
DD		 2534 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2535 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
c906108c 2536
c5fbc25b
DD		 2537 /* Set condition codes. */
2538 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
c906108c 2539
c5fbc25b
DD		 2540 if (quotient == 0) PSW |= PSW_Z;
2541 if (quotient < 0) PSW |= PSW_S;
2542 }
c906108c
SS		 2543
2544 trace_output (OP_REG_REG_REG);
2545
2546 return 4;
2547}
2548
2549/* mulu imm9, reg2, reg3 */
2550int
2551OP_24207E0 (void)
2552{
2553 trace_input ("mulu", OP_IMM_REG_REG, 0);
2554
0da2b665 2555 Multiply64 (0, (OP[3] & 0x1f) | ((OP[3] >> 13) & 0x1e0));
c906108c
SS		 2556
2557 trace_output (OP_IMM_REG_REG);
2558
2559 return 4;
2560}
2561
2562/* mul imm9, reg2, reg3 */
2563int
2564OP_24007E0 (void)
2565{
2566 trace_input ("mul", OP_IMM_REG_REG, 0);
2567
0da2b665 2568 Multiply64 (1, SEXT9 ((OP[3] & 0x1f) | ((OP[3] >> 13) & 0x1e0)));
c906108c
SS		 2569
2570 trace_output (OP_IMM_REG_REG);
2571
2572 return 4;
2573}
2574
2575/* ld.hu */
2576int
2577OP_107E0 (void)
2578{
2579 int adr;
2580
2581 trace_input ("ld.hu", OP_LOAD32, 2);
2582
2583 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
2584 adr &= ~0x1;
2585
2586 State.regs[ OP[1] ] = load_mem (adr, 2);
2587
2588 trace_output (OP_LOAD32);
2589
2590 return 4;
2591}
2592
2593
2594/* ld.bu */
2595int
2596OP_10780 (void)
2597{
2598 int adr;
2599
2600 trace_input ("ld.bu", OP_LOAD32, 1);
2601
2602 adr = (State.regs[ OP[0] ]
2603 + (EXTEND16 (OP[2] & ~1) | ((OP[3] >> 5) & 1)));
2604
2605 State.regs[ OP[1] ] = load_mem (adr, 1);
2606
2607 trace_output (OP_LOAD32);
2608
2609 return 4;
2610}
2611
2612/* prepare list12, imm5, imm32 */
2613int
2614OP_1B0780 (void)
2615{
2616 int i;
2617
2618 trace_input ("prepare", OP_PUSHPOP1, 0);
2619
2620 /* Store the registers with lower number registers being placed at higher addresses. */
2621 for (i = 0; i < 12; i++)
2622 if ((OP[3] & (1 << type1_regs[ i ])))
2623 {
2624 SP -= 4;
2625 store_mem (SP, 4, State.regs[ 20 + i ]);
2626 }
2627
2628 SP -= (OP[3] & 0x3e) << 1;
2629
2630 EP = load_mem (PC + 4, 4);
2631
2632 trace_output (OP_PUSHPOP1);
2633
2634 return 8;
2635}
2636
2637/* prepare list12, imm5, imm16-32 */
2638int
2639OP_130780 (void)
2640{
2641 int i;
2642
2643 trace_input ("prepare", OP_PUSHPOP1, 0);
2644
2645 /* Store the registers with lower number registers being placed at higher addresses. */
2646 for (i = 0; i < 12; i++)
2647 if ((OP[3] & (1 << type1_regs[ i ])))
2648 {
2649 SP -= 4;
2650 store_mem (SP, 4, State.regs[ 20 + i ]);
2651 }
2652
2653 SP -= (OP[3] & 0x3e) << 1;
2654
2655 EP = load_mem (PC + 4, 2) << 16;
2656
2657 trace_output (OP_PUSHPOP1);
2658
2659 return 6;
2660}
2661
2662/* prepare list12, imm5, imm16 */
2663int
2664OP_B0780 (void)
2665{
2666 int i;
2667
2668 trace_input ("prepare", OP_PUSHPOP1, 0);
2669
2670 /* Store the registers with lower number registers being placed at higher addresses. */
2671 for (i = 0; i < 12; i++)
2672 if ((OP[3] & (1 << type1_regs[ i ])))
2673 {
2674 SP -= 4;
2675 store_mem (SP, 4, State.regs[ 20 + i ]);
2676 }
2677
2678 SP -= (OP[3] & 0x3e) << 1;
2679
2680 EP = EXTEND16 (load_mem (PC + 4, 2));
2681
2682 trace_output (OP_PUSHPOP1);
2683
2684 return 6;
2685}
2686
2687/* prepare list12, imm5, sp */
2688int
2689OP_30780 (void)
2690{
2691 int i;
2692
2693 trace_input ("prepare", OP_PUSHPOP1, 0);
2694
2695 /* Store the registers with lower number registers being placed at higher addresses. */
2696 for (i = 0; i < 12; i++)
2697 if ((OP[3] & (1 << type1_regs[ i ])))
2698 {
2699 SP -= 4;
2700 store_mem (SP, 4, State.regs[ 20 + i ]);
2701 }
2702
2703 SP -= (OP[3] & 0x3e) << 1;
2704
2705 EP = SP;
2706
2707 trace_output (OP_PUSHPOP1);
2708
2709 return 4;
2710}
2711
2712/* mul reg1, reg2, reg3 */
2713int
2714OP_22007E0 (void)
2715{
2716 trace_input ("mul", OP_REG_REG_REG, 0);
2717
0da2b665 2718 Multiply64 (1, State.regs[ OP[0] ]);
c906108c
SS		 2719
2720 trace_output (OP_REG_REG_REG);
2721
2722 return 4;
2723}
2724
2725/* popmh list18 */
2726int
2727OP_307F0 (void)
2728{
2729 int i;
2730
2731 trace_input ("popmh", OP_PUSHPOP2, 0);
2732
2733 if (OP[3] & (1 << 19))
2734 {
2735 if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
2736 {
2737 FEPSW = load_mem ( SP & ~ 3, 4);
2738 FEPC = load_mem ((SP + 4) & ~ 3, 4);
2739 }
2740 else
2741 {
2742 EIPSW = load_mem ( SP & ~ 3, 4);
2743 EIPC = load_mem ((SP + 4) & ~ 3, 4);
2744 }
2745
2746 SP += 8;
2747 }
2748
2749 /* Load the registers with lower number registers being retrieved from higher addresses. */
2750 for (i = 16; i--;)
2751 if ((OP[3] & (1 << type2_regs[ i ])))
2752 {
2753 State.regs[ i + 16 ] = load_mem (SP & ~ 3, 4);
2754 SP += 4;
2755 }
2756
2757 trace_output (OP_PUSHPOP2);
2758
2759 return 4;
2760}
2761
2762/* popml lsit18 */
2763int
2764OP_107F0 (void)
2765{
2766 int i;
2767
2768 trace_input ("popml", OP_PUSHPOP3, 0);
2769
2770 if (OP[3] & (1 << 19))
2771 {
2772 if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
2773 {
2774 FEPSW = load_mem ( SP & ~ 3, 4);
2775 FEPC = load_mem ((SP + 4) & ~ 3, 4);
2776 }
2777 else
2778 {
2779 EIPSW = load_mem ( SP & ~ 3, 4);
2780 EIPC = load_mem ((SP + 4) & ~ 3, 4);
2781 }
2782
2783 SP += 8;
2784 }
2785
2786 if (OP[3] & (1 << 3))
2787 {
2788 PSW = load_mem (SP & ~ 3, 4);
2789 SP += 4;
2790 }
2791
2792 /* Load the registers with lower number registers being retrieved from higher addresses. */
2793 for (i = 15; i--;)
2794 if ((OP[3] & (1 << type3_regs[ i ])))
2795 {
2796 State.regs[ i + 1 ] = load_mem (SP & ~ 3, 4);
2797 SP += 4;
2798 }
2799
2800 trace_output (OP_PUSHPOP2);
2801
2802 return 4;
2803}
2804
2805/* pushmh list18 */
2806int
2807OP_307E0 (void)
2808{
2809 int i;
2810
2811 trace_input ("pushmh", OP_PUSHPOP2, 0);
2812
2813 /* Store the registers with lower number registers being placed at higher addresses. */
2814 for (i = 0; i < 16; i++)
2815 if ((OP[3] & (1 << type2_regs[ i ])))
2816 {
2817 SP -= 4;
2818 store_mem (SP & ~ 3, 4, State.regs[ i + 16 ]);
2819 }
2820
2821 if (OP[3] & (1 << 19))
2822 {
2823 SP -= 8;
2824
2825 if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
2826 {
2827 store_mem ((SP + 4) & ~ 3, 4, FEPC);
2828 store_mem ( SP & ~ 3, 4, FEPSW);
2829 }
2830 else
2831 {
2832 store_mem ((SP + 4) & ~ 3, 4, EIPC);
2833 store_mem ( SP & ~ 3, 4, EIPSW);
2834 }
2835 }
2836
2837 trace_output (OP_PUSHPOP2);
2838
2839 return 4;
2840}
2841
GDB Binutils - Deliverables
This page took 0.585307 seconds and 4 git commands to generate.