?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[PATCH 7/57][Arm][GAS] Add support for MVE instructions: vstr/vldr
[binutils-gdb.git] / sim / v850 / simops.c
blob40d578e5d0ac87e17c5716c05cae787167668af9
1 #include "sim-main.h"
2 #include "v850_sim.h"
3 #include "simops.h"
4
5 #include <sys/types.h>
6
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. */
40 int 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. */
43 int 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. */
46 int 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
58 unsigned32 trace_values[3];
59 int trace_num_values;
60 unsigned32 trace_pc;
61 const char * trace_name;
62 int trace_module;
63
64
65 void
66 trace_input (char *name, enum op_types type, int size)
67 {
68 if (!TRACE_ALU_P (STATE_CPU (simulator, 0)))
69 return;
70
71 trace_pc = PC;
72 trace_name = name;
73 trace_module = TRACE_ALU_IDX;
74
75 switch (type)
76 {
77 default:
78 case OP_UNKNOWN:
79 case OP_NONE:
80 case OP_TRAP:
81 trace_num_values = 0;
82 break;
83
84 case OP_REG:
85 case OP_REG_REG_MOVE:
86 trace_values[0] = State.regs[OP[0]];
87 trace_num_values = 1;
88 break;
89
90 case OP_BIT_CHANGE:
91 case OP_REG_REG:
92 case OP_REG_REG_CMP:
93 trace_values[0] = State.regs[OP[1]];
94 trace_values[1] = State.regs[OP[0]];
95 trace_num_values = 2;
96 break;
97
98 case OP_IMM_REG:
99 case OP_IMM_REG_CMP:
100 trace_values[0] = SEXT5 (OP[0]);
101 trace_values[1] = OP[1];
102 trace_num_values = 2;
103 break;
104
105 case OP_IMM_REG_MOVE:
106 trace_values[0] = SEXT5 (OP[0]);
107 trace_num_values = 1;
108 break;
109
110 case OP_COND_BR:
111 trace_values[0] = State.pc;
112 trace_values[1] = SEXT9 (OP[0]);
113 trace_values[2] = PSW;
114 trace_num_values = 3;
115 break;
116
117 case OP_LOAD16:
118 trace_values[0] = OP[1] * size;
119 trace_values[1] = State.regs[30];
120 trace_num_values = 2;
121 break;
122
123 case OP_STORE16:
124 trace_values[0] = State.regs[OP[0]];
125 trace_values[1] = OP[1] * size;
126 trace_values[2] = State.regs[30];
127 trace_num_values = 3;
128 break;
129
130 case OP_LOAD32:
131 trace_values[0] = EXTEND16 (OP[2]);
132 trace_values[1] = State.regs[OP[0]];
133 trace_num_values = 2;
134 break;
135
136 case OP_STORE32:
137 trace_values[0] = State.regs[OP[1]];
138 trace_values[1] = EXTEND16 (OP[2]);
139 trace_values[2] = State.regs[OP[0]];
140 trace_num_values = 3;
141 break;
142
143 case OP_JUMP:
144 trace_values[0] = SEXT22 (OP[0]);
145 trace_values[1] = State.pc;
146 trace_num_values = 2;
147 break;
148
149 case OP_IMM_REG_REG:
150 trace_values[0] = EXTEND16 (OP[0]) << size;
151 trace_values[1] = State.regs[OP[1]];
152 trace_num_values = 2;
153 break;
154
155 case OP_IMM16_REG_REG:
156 trace_values[0] = EXTEND16 (OP[2]) << size;
157 trace_values[1] = State.regs[OP[1]];
158 trace_num_values = 2;
159 break;
160
161 case OP_UIMM_REG_REG:
162 trace_values[0] = (OP[0] & 0xffff) << size;
163 trace_values[1] = State.regs[OP[1]];
164 trace_num_values = 2;
165 break;
166
167 case OP_UIMM16_REG_REG:
168 trace_values[0] = (OP[2]) << size;
169 trace_values[1] = State.regs[OP[1]];
170 trace_num_values = 2;
171 break;
172
173 case OP_BIT:
174 trace_num_values = 0;
175 break;
176
177 case OP_EX1:
178 trace_values[0] = PSW;
179 trace_num_values = 1;
180 break;
181
182 case OP_EX2:
183 trace_num_values = 0;
184 break;
185
186 case OP_LDSR:
187 trace_values[0] = State.regs[OP[0]];
188 trace_num_values = 1;
189 break;
190
191 case OP_STSR:
192 trace_values[0] = State.sregs[OP[1]];
193 trace_num_values = 1;
194 }
195
196 }
197
198 void
199 trace_result (int has_result, unsigned32 result)
200 {
201 char buf[1000];
202 char *chp;
203
204 buf[0] = '\0';
205 chp = buf;
206
207 /* write out the values saved during the trace_input call */
208 {
209 int i;
210 for (i = 0; i < trace_num_values; i++)
211 {
212 sprintf (chp, "%*s0x%.8lx", SIZE_VALUES - 10, "",
213 (long) trace_values[i]);
214 chp = strchr (chp, '\0');
215 }
216 while (i++ < 3)
217 {
218 sprintf (chp, "%*s", SIZE_VALUES, "");
219 chp = strchr (chp, '\0');
220 }
221 }
222
223 /* append any result to the end of the buffer */
224 if (has_result)
225 sprintf (chp, " :: 0x%.8lx", (unsigned long) result);
226
227 trace_generic (simulator, STATE_CPU (simulator, 0), trace_module, "%s", buf);
228 }
229
230 void
231 trace_output (enum op_types result)
232 {
233 if (!TRACE_ALU_P (STATE_CPU (simulator, 0)))
234 return;
235
236 switch (result)
237 {
238 default:
239 case OP_UNKNOWN:
240 case OP_NONE:
241 case OP_TRAP:
242 case OP_REG:
243 case OP_REG_REG_CMP:
244 case OP_IMM_REG_CMP:
245 case OP_COND_BR:
246 case OP_STORE16:
247 case OP_STORE32:
248 case OP_BIT:
249 case OP_EX2:
250 trace_result (0, 0);
251 break;
252
253 case OP_LOAD16:
254 case OP_STSR:
255 trace_result (1, State.regs[OP[0]]);
256 break;
257
258 case OP_REG_REG:
259 case OP_REG_REG_MOVE:
260 case OP_IMM_REG:
261 case OP_IMM_REG_MOVE:
262 case OP_LOAD32:
263 case OP_EX1:
264 trace_result (1, State.regs[OP[1]]);
265 break;
266
267 case OP_IMM_REG_REG:
268 case OP_UIMM_REG_REG:
269 case OP_IMM16_REG_REG:
270 case OP_UIMM16_REG_REG:
271 trace_result (1, State.regs[OP[1]]);
272 break;
273
274 case OP_JUMP:
275 if (OP[1] != 0)
276 trace_result (1, State.regs[OP[1]]);
277 else
278 trace_result (0, 0);
279 break;
280
281 case OP_LDSR:
282 trace_result (1, State.sregs[OP[1]]);
283 break;
284 }
285 }
286 #endif
287
288 \f
289 /* Returns 1 if the specific condition is met, returns 0 otherwise. */
290 int
291 condition_met (unsigned code)
292 {
293 unsigned int psw = PSW;
294
295 switch (code & 0xf)
296 {
297 case 0x0: return ((psw & PSW_OV) != 0);
298 case 0x1: return ((psw & PSW_CY) != 0);
299 case 0x2: return ((psw & PSW_Z) != 0);
300 case 0x3: return ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) != 0);
301 case 0x4: return ((psw & PSW_S) != 0);
302 /*case 0x5: return 1;*/
303 case 0x6: return ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) != 0);
304 case 0x7: return (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) || ((psw & PSW_Z) != 0)) != 0);
305 case 0x8: return ((psw & PSW_OV) == 0);
306 case 0x9: return ((psw & PSW_CY) == 0);
307 case 0xa: return ((psw & PSW_Z) == 0);
308 case 0xb: return ((((psw & PSW_CY) != 0) | ((psw & PSW_Z) != 0)) == 0);
309 case 0xc: return ((psw & PSW_S) == 0);
310 case 0xd: return ((psw & PSW_SAT) != 0);
311 case 0xe: return ((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) == 0);
312 case 0xf: return (((((psw & PSW_S) != 0) ^ ((psw & PSW_OV) != 0)) || ((psw & PSW_Z) != 0)) == 0);
313 }
314
315 return 1;
316 }
317
318 unsigned long
319 Add32 (unsigned long a1, unsigned long a2, int * carry)
320 {
321 unsigned long result = (a1 + a2);
322
323 * carry = (result < a1);
324
325 return result;
326 }
327
328 static void
329 Multiply64 (int sign, unsigned long op0)
330 {
331 unsigned long op1;
332 unsigned long lo;
333 unsigned long mid1;
334 unsigned long mid2;
335 unsigned long hi;
336 unsigned long RdLo;
337 unsigned long RdHi;
338 int carry;
339
340 op1 = State.regs[ OP[1] ];
341
342 if (sign)
343 {
344 /* Compute sign of result and adjust operands if necessary. */
345
346 sign = (op0 ^ op1) & 0x80000000;
347
348 if (((signed long) op0) < 0)
349 op0 = - op0;
350
351 if (((signed long) op1) < 0)
352 op1 = - op1;
353 }
354
355 /* We can split the 32x32 into four 16x16 operations. This ensures
356 that we do not lose precision on 32bit only hosts: */
357 lo = ( (op0 & 0xFFFF) * (op1 & 0xFFFF));
358 mid1 = ( (op0 & 0xFFFF) * ((op1 >> 16) & 0xFFFF));
359 mid2 = (((op0 >> 16) & 0xFFFF) * (op1 & 0xFFFF));
360 hi = (((op0 >> 16) & 0xFFFF) * ((op1 >> 16) & 0xFFFF));
361
362 /* We now need to add all of these results together, taking care
363 to propogate the carries from the additions: */
364 RdLo = Add32 (lo, (mid1 << 16), & carry);
365 RdHi = carry;
366 RdLo = Add32 (RdLo, (mid2 << 16), & carry);
367 RdHi += (carry + ((mid1 >> 16) & 0xFFFF) + ((mid2 >> 16) & 0xFFFF) + hi);
368
369 if (sign)
370 {
371 /* Negate result if necessary. */
372
373 RdLo = ~ RdLo;
374 RdHi = ~ RdHi;
375 if (RdLo == 0xFFFFFFFF)
376 {
377 RdLo = 0;
378 RdHi += 1;
379 }
380 else
381 RdLo += 1;
382 }
383
384 /* Don't store into register 0. */
385 if (OP[1])
386 State.regs[ OP[1] ] = RdLo;
387 if (OP[2] >> 11)
388 State.regs[ OP[2] >> 11 ] = RdHi;
389
390 return;
391 }
392
393 \f
394 /* Read a null terminated string from memory, return in a buffer. */
395
396 static char *
397 fetch_str (SIM_DESC sd, address_word addr)
398 {
399 char *buf;
400 int nr = 0;
401
402 while (sim_core_read_1 (STATE_CPU (sd, 0),
403 PC, read_map, addr + nr) != 0)
404 nr++;
405
406 buf = NZALLOC (char, nr + 1);
407 sim_read (simulator, addr, (unsigned char *) buf, nr);
408
409 return buf;
410 }
411
412 /* Read a null terminated argument vector from memory, return in a
413 buffer. */
414
415 static char **
416 fetch_argv (SIM_DESC sd, address_word addr)
417 {
418 int max_nr = 64;
419 int nr = 0;
420 char **buf = xmalloc (max_nr * sizeof (char*));
421
422 while (1)
423 {
424 unsigned32 a = sim_core_read_4 (STATE_CPU (sd, 0),
425 PC, read_map, addr + nr * 4);
426 if (a == 0) break;
427 buf[nr] = fetch_str (sd, a);
428 nr ++;
429 if (nr == max_nr - 1)
430 {
431 max_nr += 50;
432 buf = xrealloc (buf, max_nr * sizeof (char*));
433 }
434 }
435 buf[nr] = 0;
436 return buf;
437 }
438
439 \f
440 /* sst.b */
441 int
442 OP_380 (void)
443 {
444 trace_input ("sst.b", OP_STORE16, 1);
445
446 store_mem (State.regs[30] + (OP[3] & 0x7f), 1, State.regs[ OP[1] ]);
447
448 trace_output (OP_STORE16);
449
450 return 2;
451 }
452
453 /* sst.h */
454 int
455 OP_480 (void)
456 {
457 trace_input ("sst.h", OP_STORE16, 2);
458
459 store_mem (State.regs[30] + ((OP[3] & 0x7f) << 1), 2, State.regs[ OP[1] ]);
460
461 trace_output (OP_STORE16);
462
463 return 2;
464 }
465
466 /* sst.w */
467 int
468 OP_501 (void)
469 {
470 trace_input ("sst.w", OP_STORE16, 4);
471
472 store_mem (State.regs[30] + ((OP[3] & 0x7e) << 1), 4, State.regs[ OP[1] ]);
473
474 trace_output (OP_STORE16);
475
476 return 2;
477 }
478
479 /* ld.b */
480 int
481 OP_700 (void)
482 {
483 int adr;
484
485 trace_input ("ld.b", OP_LOAD32, 1);
486
487 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
488
489 State.regs[ OP[1] ] = EXTEND8 (load_mem (adr, 1));
490
491 trace_output (OP_LOAD32);
492
493 return 4;
494 }
495
496 /* ld.h */
497 int
498 OP_720 (void)
499 {
500 int adr;
501
502 trace_input ("ld.h", OP_LOAD32, 2);
503
504 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
505 adr &= ~0x1;
506
507 State.regs[ OP[1] ] = EXTEND16 (load_mem (adr, 2));
508
509 trace_output (OP_LOAD32);
510
511 return 4;
512 }
513
514 /* ld.w */
515 int
516 OP_10720 (void)
517 {
518 int adr;
519
520 trace_input ("ld.w", OP_LOAD32, 4);
521
522 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
523 adr &= ~0x3;
524
525 State.regs[ OP[1] ] = load_mem (adr, 4);
526
527 trace_output (OP_LOAD32);
528
529 return 4;
530 }
531
532 /* st.b */
533 int
534 OP_740 (void)
535 {
536 trace_input ("st.b", OP_STORE32, 1);
537
538 store_mem (State.regs[ OP[0] ] + EXTEND16 (OP[2]), 1, State.regs[ OP[1] ]);
539
540 trace_output (OP_STORE32);
541
542 return 4;
543 }
544
545 /* st.h */
546 int
547 OP_760 (void)
548 {
549 int adr;
550
551 trace_input ("st.h", OP_STORE32, 2);
552
553 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2]);
554 adr &= ~1;
555
556 store_mem (adr, 2, State.regs[ OP[1] ]);
557
558 trace_output (OP_STORE32);
559
560 return 4;
561 }
562
563 /* st.w */
564 int
565 OP_10760 (void)
566 {
567 int adr;
568
569 trace_input ("st.w", OP_STORE32, 4);
570
571 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
572 adr &= ~3;
573
574 store_mem (adr, 4, State.regs[ OP[1] ]);
575
576 trace_output (OP_STORE32);
577
578 return 4;
579 }
580
581 /* add reg, reg */
582 int
583 OP_1C0 (void)
584 {
585 unsigned int op0, op1, result, z, s, cy, ov;
586
587 trace_input ("add", OP_REG_REG, 0);
588
589 /* Compute the result. */
590
591 op0 = State.regs[ OP[0] ];
592 op1 = State.regs[ OP[1] ];
593
594 result = op0 + op1;
595
596 /* Compute the condition codes. */
597 z = (result == 0);
598 s = (result & 0x80000000);
599 cy = (result < op0 || result < op1);
600 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
601 && (op0 & 0x80000000) != (result & 0x80000000));
602
603 /* Store the result and condition codes. */
604 State.regs[OP[1]] = result;
605 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
606 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
607 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
608 trace_output (OP_REG_REG);
609
610 return 2;
611 }
612
613 /* add sign_extend(imm5), reg */
614 int
615 OP_240 (void)
616 {
617 unsigned int op0, op1, result, z, s, cy, ov;
618 int temp;
619
620 trace_input ("add", OP_IMM_REG, 0);
621
622 /* Compute the result. */
623 temp = SEXT5 (OP[0]);
624 op0 = temp;
625 op1 = State.regs[OP[1]];
626 result = op0 + op1;
627
628 /* Compute the condition codes. */
629 z = (result == 0);
630 s = (result & 0x80000000);
631 cy = (result < op0 || result < op1);
632 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
633 && (op0 & 0x80000000) != (result & 0x80000000));
634
635 /* Store the result and condition codes. */
636 State.regs[OP[1]] = result;
637 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
638 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
639 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
640 trace_output (OP_IMM_REG);
641
642 return 2;
643 }
644
645 /* addi sign_extend(imm16), reg, reg */
646 int
647 OP_600 (void)
648 {
649 unsigned int op0, op1, result, z, s, cy, ov;
650
651 trace_input ("addi", OP_IMM16_REG_REG, 0);
652
653 /* Compute the result. */
654
655 op0 = EXTEND16 (OP[2]);
656 op1 = State.regs[ OP[0] ];
657 result = op0 + op1;
658
659 /* Compute the condition codes. */
660 z = (result == 0);
661 s = (result & 0x80000000);
662 cy = (result < op0 || result < op1);
663 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
664 && (op0 & 0x80000000) != (result & 0x80000000));
665
666 /* Store the result and condition codes. */
667 State.regs[OP[1]] = result;
668 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
669 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
670 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
671 trace_output (OP_IMM16_REG_REG);
672
673 return 4;
674 }
675
676 /* sub reg1, reg2 */
677 int
678 OP_1A0 (void)
679 {
680 unsigned int op0, op1, result, z, s, cy, ov;
681
682 trace_input ("sub", OP_REG_REG, 0);
683 /* Compute the result. */
684 op0 = State.regs[ OP[0] ];
685 op1 = State.regs[ OP[1] ];
686 result = op1 - op0;
687
688 /* Compute the condition codes. */
689 z = (result == 0);
690 s = (result & 0x80000000);
691 cy = (op1 < op0);
692 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
693 && (op1 & 0x80000000) != (result & 0x80000000));
694
695 /* Store the result and condition codes. */
696 State.regs[OP[1]] = result;
697 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
698 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
699 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
700 trace_output (OP_REG_REG);
701
702 return 2;
703 }
704
705 /* subr reg1, reg2 */
706 int
707 OP_180 (void)
708 {
709 unsigned int op0, op1, result, z, s, cy, ov;
710
711 trace_input ("subr", OP_REG_REG, 0);
712 /* Compute the result. */
713 op0 = State.regs[ OP[0] ];
714 op1 = State.regs[ OP[1] ];
715 result = op0 - op1;
716
717 /* Compute the condition codes. */
718 z = (result == 0);
719 s = (result & 0x80000000);
720 cy = (op0 < op1);
721 ov = ((op0 & 0x80000000) != (op1 & 0x80000000)
722 && (op0 & 0x80000000) != (result & 0x80000000));
723
724 /* Store the result and condition codes. */
725 State.regs[OP[1]] = result;
726 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
727 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
728 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
729 trace_output (OP_REG_REG);
730
731 return 2;
732 }
733
734 /* sxh reg1 */
735 int
736 OP_E0 (void)
737 {
738 trace_input ("mulh", OP_REG_REG, 0);
739
740 State.regs[ OP[1] ] = (EXTEND16 (State.regs[ OP[1] ]) * EXTEND16 (State.regs[ OP[0] ]));
741
742 trace_output (OP_REG_REG);
743
744 return 2;
745 }
746
747 /* mulh sign_extend(imm5), reg2 */
748 int
749 OP_2E0 (void)
750 {
751 trace_input ("mulh", OP_IMM_REG, 0);
752
753 State.regs[ OP[1] ] = EXTEND16 (State.regs[ OP[1] ]) * SEXT5 (OP[0]);
754
755 trace_output (OP_IMM_REG);
756
757 return 2;
758 }
759
760 /* mulhi imm16, reg1, reg2 */
761 int
762 OP_6E0 (void)
763 {
764 trace_input ("mulhi", OP_IMM16_REG_REG, 0);
765
766 State.regs[ OP[1] ] = EXTEND16 (State.regs[ OP[0] ]) * EXTEND16 (OP[2]);
767
768 trace_output (OP_IMM16_REG_REG);
769
770 return 4;
771 }
772
773 /* cmp reg, reg */
774 int
775 OP_1E0 (void)
776 {
777 unsigned int op0, op1, result, z, s, cy, ov;
778
779 trace_input ("cmp", OP_REG_REG_CMP, 0);
780 /* Compute the result. */
781 op0 = State.regs[ OP[0] ];
782 op1 = State.regs[ OP[1] ];
783 result = op1 - op0;
784
785 /* Compute the condition codes. */
786 z = (result == 0);
787 s = (result & 0x80000000);
788 cy = (op1 < op0);
789 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
790 && (op1 & 0x80000000) != (result & 0x80000000));
791
792 /* Set condition codes. */
793 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
794 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
795 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
796 trace_output (OP_REG_REG_CMP);
797
798 return 2;
799 }
800
801 /* cmp sign_extend(imm5), reg */
802 int
803 OP_260 (void)
804 {
805 unsigned int op0, op1, result, z, s, cy, ov;
806 int temp;
807
808 /* Compute the result. */
809 trace_input ("cmp", OP_IMM_REG_CMP, 0);
810 temp = SEXT5 (OP[0]);
811 op0 = temp;
812 op1 = State.regs[OP[1]];
813 result = op1 - op0;
814
815 /* Compute the condition codes. */
816 z = (result == 0);
817 s = (result & 0x80000000);
818 cy = (op1 < op0);
819 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
820 && (op1 & 0x80000000) != (result & 0x80000000));
821
822 /* Set condition codes. */
823 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
824 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
825 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0));
826 trace_output (OP_IMM_REG_CMP);
827
828 return 2;
829 }
830
831 /* setf cccc,reg2 */
832 int
833 OP_7E0 (void)
834 {
835 trace_input ("setf", OP_EX1, 0);
836
837 State.regs[ OP[1] ] = condition_met (OP[0]);
838
839 trace_output (OP_EX1);
840
841 return 4;
842 }
843
844 /* satadd reg,reg */
845 int
846 OP_C0 (void)
847 {
848 unsigned int op0, op1, result, z, s, cy, ov, sat;
849
850 trace_input ("satadd", OP_REG_REG, 0);
851 /* Compute the result. */
852 op0 = State.regs[ OP[0] ];
853 op1 = State.regs[ OP[1] ];
854 result = op0 + op1;
855
856 /* Compute the condition codes. */
857 z = (result == 0);
858 s = (result & 0x80000000);
859 cy = (result < op0 || result < op1);
860 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
861 && (op0 & 0x80000000) != (result & 0x80000000));
862 sat = ov;
863
864 /* Handle saturated results. */
865 if (sat && s)
866 {
867 /* An overflow that results in a negative result implies that we
868 became too positive. */
869 result = 0x7fffffff;
870 s = 0;
871 }
872 else if (sat)
873 {
874 /* Any other overflow must have thus been too negative. */
875 result = 0x80000000;
876 s = 1;
877 z = 0;
878 }
879
880 /* Store the result and condition codes. */
881 State.regs[OP[1]] = result;
882 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
883 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
884 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
885 | (sat ? PSW_SAT : 0));
886
887 trace_output (OP_REG_REG);
888
889 return 2;
890 }
891
892 /* satadd sign_extend(imm5), reg */
893 int
894 OP_220 (void)
895 {
896 unsigned int op0, op1, result, z, s, cy, ov, sat;
897
898 int temp;
899
900 trace_input ("satadd", OP_IMM_REG, 0);
901
902 /* Compute the result. */
903 temp = SEXT5 (OP[0]);
904 op0 = temp;
905 op1 = State.regs[OP[1]];
906 result = op0 + op1;
907
908 /* Compute the condition codes. */
909 z = (result == 0);
910 s = (result & 0x80000000);
911 cy = (result < op0 || result < op1);
912 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
913 && (op0 & 0x80000000) != (result & 0x80000000));
914 sat = ov;
915
916 /* Handle saturated results. */
917 if (sat && s)
918 {
919 /* An overflow that results in a negative result implies that we
920 became too positive. */
921 result = 0x7fffffff;
922 s = 0;
923 }
924 else if (sat)
925 {
926 /* Any other overflow must have thus been too negative. */
927 result = 0x80000000;
928 s = 1;
929 z = 0;
930 }
931
932 /* Store the result and condition codes. */
933 State.regs[OP[1]] = result;
934 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
935 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
936 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
937 | (sat ? PSW_SAT : 0));
938 trace_output (OP_IMM_REG);
939
940 return 2;
941 }
942
943 /* satsub reg1, reg2 */
944 int
945 OP_A0 (void)
946 {
947 unsigned int op0, op1, result, z, s, cy, ov, sat;
948
949 trace_input ("satsub", OP_REG_REG, 0);
950
951 /* Compute the result. */
952 op0 = State.regs[ OP[0] ];
953 op1 = State.regs[ OP[1] ];
954 result = op1 - op0;
955
956 /* Compute the condition codes. */
957 z = (result == 0);
958 s = (result & 0x80000000);
959 cy = (op1 < op0);
960 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
961 && (op1 & 0x80000000) != (result & 0x80000000));
962 sat = ov;
963
964 /* Handle saturated results. */
965 if (sat && s)
966 {
967 /* An overflow that results in a negative result implies that we
968 became too positive. */
969 result = 0x7fffffff;
970 s = 0;
971 }
972 else if (sat)
973 {
974 /* Any other overflow must have thus been too negative. */
975 result = 0x80000000;
976 s = 1;
977 z = 0;
978 }
979
980 /* Store the result and condition codes. */
981 State.regs[OP[1]] = result;
982 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
983 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
984 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
985 | (sat ? PSW_SAT : 0));
986
987 trace_output (OP_REG_REG);
988 return 2;
989 }
990
991 /* satsubi sign_extend(imm16), reg */
992 int
993 OP_660 (void)
994 {
995 unsigned int op0, op1, result, z, s, cy, ov, sat;
996 int temp;
997
998 trace_input ("satsubi", OP_IMM_REG, 0);
999
1000 /* Compute the result. */
1001 temp = EXTEND16 (OP[2]);
1002 op0 = temp;
1003 op1 = State.regs[ OP[0] ];
1004 result = op1 - op0;
1005
1006 /* Compute the condition codes. */
1007 z = (result == 0);
1008 s = (result & 0x80000000);
1009 cy = (op1 < op0);
1010 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
1011 && (op1 & 0x80000000) != (result & 0x80000000));
1012 sat = ov;
1013
1014 /* Handle saturated results. */
1015 if (sat && s)
1016 {
1017 /* An overflow that results in a negative result implies that we
1018 became too positive. */
1019 result = 0x7fffffff;
1020 s = 0;
1021 }
1022 else if (sat)
1023 {
1024 /* Any other overflow must have thus been too negative. */
1025 result = 0x80000000;
1026 s = 1;
1027 z = 0;
1028 }
1029
1030 /* Store the result and condition codes. */
1031 State.regs[OP[1]] = result;
1032 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1033 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1034 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1035 | (sat ? PSW_SAT : 0));
1036
1037 trace_output (OP_IMM_REG);
1038
1039 return 4;
1040 }
1041
1042 /* satsubr reg,reg */
1043 int
1044 OP_80 (void)
1045 {
1046 unsigned int op0, op1, result, z, s, cy, ov, sat;
1047
1048 trace_input ("satsubr", OP_REG_REG, 0);
1049
1050 /* Compute the result. */
1051 op0 = State.regs[ OP[0] ];
1052 op1 = State.regs[ OP[1] ];
1053 result = op0 - op1;
1054
1055 /* Compute the condition codes. */
1056 z = (result == 0);
1057 s = (result & 0x80000000);
1058 cy = (op0 < op1);
1059 ov = ((op0 & 0x80000000) != (op1 & 0x80000000)
1060 && (op0 & 0x80000000) != (result & 0x80000000));
1061 sat = ov;
1062
1063 /* Handle saturated results. */
1064 if (sat && s)
1065 {
1066 /* An overflow that results in a negative result implies that we
1067 became too positive. */
1068 result = 0x7fffffff;
1069 s = 0;
1070 }
1071 else if (sat)
1072 {
1073 /* Any other overflow must have thus been too negative. */
1074 result = 0x80000000;
1075 s = 1;
1076 z = 0;
1077 }
1078
1079 /* Store the result and condition codes. */
1080 State.regs[OP[1]] = result;
1081 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
1082 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1083 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
1084 | (sat ? PSW_SAT : 0));
1085
1086 trace_output (OP_REG_REG);
1087
1088 return 2;
1089 }
1090
1091 /* tst reg,reg */
1092 int
1093 OP_160 (void)
1094 {
1095 unsigned int op0, op1, result, z, s;
1096
1097 trace_input ("tst", OP_REG_REG_CMP, 0);
1098
1099 /* Compute the result. */
1100 op0 = State.regs[ OP[0] ];
1101 op1 = State.regs[ OP[1] ];
1102 result = op0 & op1;
1103
1104 /* Compute the condition codes. */
1105 z = (result == 0);
1106 s = (result & 0x80000000);
1107
1108 /* Store the condition codes. */
1109 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1110 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1111 trace_output (OP_REG_REG_CMP);
1112
1113 return 2;
1114 }
1115
1116 /* mov sign_extend(imm5), reg */
1117 int
1118 OP_200 (void)
1119 {
1120 int value = SEXT5 (OP[0]);
1121
1122 trace_input ("mov", OP_IMM_REG_MOVE, 0);
1123
1124 State.regs[ OP[1] ] = value;
1125
1126 trace_output (OP_IMM_REG_MOVE);
1127
1128 return 2;
1129 }
1130
1131 /* movhi imm16, reg, reg */
1132 int
1133 OP_640 (void)
1134 {
1135 trace_input ("movhi", OP_UIMM16_REG_REG, 16);
1136
1137 State.regs[ OP[1] ] = State.regs[ OP[0] ] + (OP[2] << 16);
1138
1139 trace_output (OP_UIMM16_REG_REG);
1140
1141 return 4;
1142 }
1143
1144 /* sar zero_extend(imm5),reg1 */
1145 int
1146 OP_2A0 (void)
1147 {
1148 unsigned int op0, op1, result, z, s, cy;
1149
1150 trace_input ("sar", OP_IMM_REG, 0);
1151 op0 = OP[0];
1152 op1 = State.regs[ OP[1] ];
1153 result = (signed)op1 >> op0;
1154
1155 /* Compute the condition codes. */
1156 z = (result == 0);
1157 s = (result & 0x80000000);
1158 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
1159
1160 /* Store the result and condition codes. */
1161 State.regs[ OP[1] ] = result;
1162 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1163 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1164 | (cy ? PSW_CY : 0));
1165 trace_output (OP_IMM_REG);
1166
1167 return 2;
1168 }
1169
1170 /* sar reg1, reg2 */
1171 int
1172 OP_A007E0 (void)
1173 {
1174 unsigned int op0, op1, result, z, s, cy;
1175
1176 trace_input ("sar", OP_REG_REG, 0);
1177
1178 op0 = State.regs[ OP[0] ] & 0x1f;
1179 op1 = State.regs[ OP[1] ];
1180 result = (signed)op1 >> op0;
1181
1182 /* Compute the condition codes. */
1183 z = (result == 0);
1184 s = (result & 0x80000000);
1185 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
1186
1187 /* Store the result and condition codes. */
1188 State.regs[OP[1]] = result;
1189 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1190 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1191 | (cy ? PSW_CY : 0));
1192 trace_output (OP_REG_REG);
1193
1194 return 4;
1195 }
1196
1197 /* shl zero_extend(imm5),reg1 */
1198 int
1199 OP_2C0 (void)
1200 {
1201 unsigned int op0, op1, result, z, s, cy;
1202
1203 trace_input ("shl", OP_IMM_REG, 0);
1204 op0 = OP[0];
1205 op1 = State.regs[ OP[1] ];
1206 result = op1 << op0;
1207
1208 /* Compute the condition codes. */
1209 z = (result == 0);
1210 s = (result & 0x80000000);
1211 cy = op0 ? (op1 & (1 << (32 - op0))) : 0;
1212
1213 /* Store the result and condition codes. */
1214 State.regs[OP[1]] = result;
1215 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1216 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1217 | (cy ? PSW_CY : 0));
1218 trace_output (OP_IMM_REG);
1219
1220 return 2;
1221 }
1222
1223 /* shl reg1, reg2 */
1224 int
1225 OP_C007E0 (void)
1226 {
1227 unsigned int op0, op1, result, z, s, cy;
1228
1229 trace_input ("shl", OP_REG_REG, 0);
1230 op0 = State.regs[ OP[0] ] & 0x1f;
1231 op1 = State.regs[ OP[1] ];
1232 result = op1 << op0;
1233
1234 /* Compute the condition codes. */
1235 z = (result == 0);
1236 s = (result & 0x80000000);
1237 cy = op0 ? (op1 & (1 << (32 - op0))) : 0;
1238
1239 /* Store the result and condition codes. */
1240 State.regs[OP[1]] = result;
1241 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1242 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1243 | (cy ? PSW_CY : 0));
1244 trace_output (OP_REG_REG);
1245
1246 return 4;
1247 }
1248
1249 /* shr zero_extend(imm5),reg1 */
1250 int
1251 OP_280 (void)
1252 {
1253 unsigned int op0, op1, result, z, s, cy;
1254
1255 trace_input ("shr", OP_IMM_REG, 0);
1256 op0 = OP[0];
1257 op1 = State.regs[ OP[1] ];
1258 result = op1 >> op0;
1259
1260 /* Compute the condition codes. */
1261 z = (result == 0);
1262 s = (result & 0x80000000);
1263 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
1264
1265 /* Store the result and condition codes. */
1266 State.regs[OP[1]] = result;
1267 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1268 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1269 | (cy ? PSW_CY : 0));
1270 trace_output (OP_IMM_REG);
1271
1272 return 2;
1273 }
1274
1275 /* shr reg1, reg2 */
1276 int
1277 OP_8007E0 (void)
1278 {
1279 unsigned int op0, op1, result, z, s, cy;
1280
1281 trace_input ("shr", OP_REG_REG, 0);
1282 op0 = State.regs[ OP[0] ] & 0x1f;
1283 op1 = State.regs[ OP[1] ];
1284 result = op1 >> op0;
1285
1286 /* Compute the condition codes. */
1287 z = (result == 0);
1288 s = (result & 0x80000000);
1289 cy = op0 ? (op1 & (1 << (op0 - 1))) : 0;
1290
1291 /* Store the result and condition codes. */
1292 State.regs[OP[1]] = result;
1293 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
1294 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
1295 | (cy ? PSW_CY : 0));
1296 trace_output (OP_REG_REG);
1297
1298 return 4;
1299 }
1300
1301 /* or reg, reg */
1302 int
1303 OP_100 (void)
1304 {
1305 unsigned int op0, op1, result, z, s;
1306
1307 trace_input ("or", OP_REG_REG, 0);
1308
1309 /* Compute the result. */
1310 op0 = State.regs[ OP[0] ];
1311 op1 = State.regs[ OP[1] ];
1312 result = op0 | op1;
1313
1314 /* Compute the condition codes. */
1315 z = (result == 0);
1316 s = (result & 0x80000000);
1317
1318 /* Store the result and condition codes. */
1319 State.regs[OP[1]] = result;
1320 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1321 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1322 trace_output (OP_REG_REG);
1323
1324 return 2;
1325 }
1326
1327 /* ori zero_extend(imm16), reg, reg */
1328 int
1329 OP_680 (void)
1330 {
1331 unsigned int op0, op1, result, z, s;
1332
1333 trace_input ("ori", OP_UIMM16_REG_REG, 0);
1334 op0 = OP[2];
1335 op1 = State.regs[ OP[0] ];
1336 result = op0 | op1;
1337
1338 /* Compute the condition codes. */
1339 z = (result == 0);
1340 s = (result & 0x80000000);
1341
1342 /* Store the result and condition codes. */
1343 State.regs[OP[1]] = result;
1344 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1345 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1346 trace_output (OP_UIMM16_REG_REG);
1347
1348 return 4;
1349 }
1350
1351 /* and reg, reg */
1352 int
1353 OP_140 (void)
1354 {
1355 unsigned int op0, op1, result, z, s;
1356
1357 trace_input ("and", OP_REG_REG, 0);
1358
1359 /* Compute the result. */
1360 op0 = State.regs[ OP[0] ];
1361 op1 = State.regs[ OP[1] ];
1362 result = op0 & op1;
1363
1364 /* Compute the condition codes. */
1365 z = (result == 0);
1366 s = (result & 0x80000000);
1367
1368 /* Store the result and condition codes. */
1369 State.regs[OP[1]] = result;
1370 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1371 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1372 trace_output (OP_REG_REG);
1373
1374 return 2;
1375 }
1376
1377 /* andi zero_extend(imm16), reg, reg */
1378 int
1379 OP_6C0 (void)
1380 {
1381 unsigned int result, z;
1382
1383 trace_input ("andi", OP_UIMM16_REG_REG, 0);
1384
1385 result = OP[2] & State.regs[ OP[0] ];
1386
1387 /* Compute the condition codes. */
1388 z = (result == 0);
1389
1390 /* Store the result and condition codes. */
1391 State.regs[ OP[1] ] = result;
1392
1393 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1394 PSW |= (z ? PSW_Z : 0);
1395
1396 trace_output (OP_UIMM16_REG_REG);
1397
1398 return 4;
1399 }
1400
1401 /* xor reg, reg */
1402 int
1403 OP_120 (void)
1404 {
1405 unsigned int op0, op1, result, z, s;
1406
1407 trace_input ("xor", OP_REG_REG, 0);
1408
1409 /* Compute the result. */
1410 op0 = State.regs[ OP[0] ];
1411 op1 = State.regs[ OP[1] ];
1412 result = op0 ^ op1;
1413
1414 /* Compute the condition codes. */
1415 z = (result == 0);
1416 s = (result & 0x80000000);
1417
1418 /* Store the result and condition codes. */
1419 State.regs[OP[1]] = result;
1420 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1421 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1422 trace_output (OP_REG_REG);
1423
1424 return 2;
1425 }
1426
1427 /* xori zero_extend(imm16), reg, reg */
1428 int
1429 OP_6A0 (void)
1430 {
1431 unsigned int op0, op1, result, z, s;
1432
1433 trace_input ("xori", OP_UIMM16_REG_REG, 0);
1434 op0 = OP[2];
1435 op1 = State.regs[ OP[0] ];
1436 result = op0 ^ op1;
1437
1438 /* Compute the condition codes. */
1439 z = (result == 0);
1440 s = (result & 0x80000000);
1441
1442 /* Store the result and condition codes. */
1443 State.regs[OP[1]] = result;
1444 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1445 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1446 trace_output (OP_UIMM16_REG_REG);
1447
1448 return 4;
1449 }
1450
1451 /* not reg1, reg2 */
1452 int
1453 OP_20 (void)
1454 {
1455 unsigned int op0, result, z, s;
1456
1457 trace_input ("not", OP_REG_REG_MOVE, 0);
1458 /* Compute the result. */
1459 op0 = State.regs[ OP[0] ];
1460 result = ~op0;
1461
1462 /* Compute the condition codes. */
1463 z = (result == 0);
1464 s = (result & 0x80000000);
1465
1466 /* Store the result and condition codes. */
1467 State.regs[OP[1]] = result;
1468 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
1469 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0));
1470 trace_output (OP_REG_REG_MOVE);
1471
1472 return 2;
1473 }
1474
1475 /* set1 */
1476 int
1477 OP_7C0 (void)
1478 {
1479 unsigned int op0, op1, op2;
1480 int temp;
1481
1482 trace_input ("set1", OP_BIT, 0);
1483 op0 = State.regs[ OP[0] ];
1484 op1 = OP[1] & 0x7;
1485 temp = EXTEND16 (OP[2]);
1486 op2 = temp;
1487 temp = load_mem (op0 + op2, 1);
1488 PSW &= ~PSW_Z;
1489 if ((temp & (1 << op1)) == 0)
1490 PSW |= PSW_Z;
1491 temp |= (1 << op1);
1492 store_mem (op0 + op2, 1, temp);
1493 trace_output (OP_BIT);
1494
1495 return 4;
1496 }
1497
1498 /* not1 */
1499 int
1500 OP_47C0 (void)
1501 {
1502 unsigned int op0, op1, op2;
1503 int temp;
1504
1505 trace_input ("not1", OP_BIT, 0);
1506 op0 = State.regs[ OP[0] ];
1507 op1 = OP[1] & 0x7;
1508 temp = EXTEND16 (OP[2]);
1509 op2 = temp;
1510 temp = load_mem (op0 + op2, 1);
1511 PSW &= ~PSW_Z;
1512 if ((temp & (1 << op1)) == 0)
1513 PSW |= PSW_Z;
1514 temp ^= (1 << op1);
1515 store_mem (op0 + op2, 1, temp);
1516 trace_output (OP_BIT);
1517
1518 return 4;
1519 }
1520
1521 /* clr1 */
1522 int
1523 OP_87C0 (void)
1524 {
1525 unsigned int op0, op1, op2;
1526 int temp;
1527
1528 trace_input ("clr1", OP_BIT, 0);
1529 op0 = State.regs[ OP[0] ];
1530 op1 = OP[1] & 0x7;
1531 temp = EXTEND16 (OP[2]);
1532 op2 = temp;
1533 temp = load_mem (op0 + op2, 1);
1534 PSW &= ~PSW_Z;
1535 if ((temp & (1 << op1)) == 0)
1536 PSW |= PSW_Z;
1537 temp &= ~(1 << op1);
1538 store_mem (op0 + op2, 1, temp);
1539 trace_output (OP_BIT);
1540
1541 return 4;
1542 }
1543
1544 /* tst1 */
1545 int
1546 OP_C7C0 (void)
1547 {
1548 unsigned int op0, op1, op2;
1549 int temp;
1550
1551 trace_input ("tst1", OP_BIT, 0);
1552 op0 = State.regs[ OP[0] ];
1553 op1 = OP[1] & 0x7;
1554 temp = EXTEND16 (OP[2]);
1555 op2 = temp;
1556 temp = load_mem (op0 + op2, 1);
1557 PSW &= ~PSW_Z;
1558 if ((temp & (1 << op1)) == 0)
1559 PSW |= PSW_Z;
1560 trace_output (OP_BIT);
1561
1562 return 4;
1563 }
1564
1565 /* di */
1566 int
1567 OP_16007E0 (void)
1568 {
1569 trace_input ("di", OP_NONE, 0);
1570 PSW |= PSW_ID;
1571 trace_output (OP_NONE);
1572
1573 return 4;
1574 }
1575
1576 /* ei */
1577 int
1578 OP_16087E0 (void)
1579 {
1580 trace_input ("ei", OP_NONE, 0);
1581 PSW &= ~PSW_ID;
1582 trace_output (OP_NONE);
1583
1584 return 4;
1585 }
1586
1587 /* halt */
1588 int
1589 OP_12007E0 (void)
1590 {
1591 trace_input ("halt", OP_NONE, 0);
1592 /* FIXME this should put processor into a mode where NMI still handled */
1593 trace_output (OP_NONE);
1594 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1595 sim_stopped, SIM_SIGTRAP);
1596 return 0;
1597 }
1598
1599 /* trap */
1600 int
1601 OP_10007E0 (void)
1602 {
1603 trace_input ("trap", OP_TRAP, 0);
1604 trace_output (OP_TRAP);
1605
1606 /* Trap 31 is used for simulating OS I/O functions */
1607
1608 if (OP[0] == 31)
1609 {
1610 int save_errno = errno;
1611 errno = 0;
1612
1613 /* Registers passed to trap 0 */
1614
1615 #define FUNC State.regs[6] /* function number, return value */
1616 #define PARM1 State.regs[7] /* optional parm 1 */
1617 #define PARM2 State.regs[8] /* optional parm 2 */
1618 #define PARM3 State.regs[9] /* optional parm 3 */
1619
1620 /* Registers set by trap 0 */
1621
1622 #define RETVAL State.regs[10] /* return value */
1623 #define RETERR State.regs[11] /* return error code */
1624
1625 /* Turn a pointer in a register into a pointer into real memory. */
1626
1627 #define MEMPTR(x) (map (x))
1628
1629 RETERR = 0;
1630
1631 switch (FUNC)
1632 {
1633
1634 #ifdef HAVE_FORK
1635 #ifdef TARGET_SYS_fork
1636 case TARGET_SYS_fork:
1637 RETVAL = fork ();
1638 RETERR = errno;
1639 break;
1640 #endif
1641 #endif
1642
1643 #ifdef HAVE_EXECVE
1644 #ifdef TARGET_SYS_execv
1645 case TARGET_SYS_execve:
1646 {
1647 char *path = fetch_str (simulator, PARM1);
1648 char **argv = fetch_argv (simulator, PARM2);
1649 char **envp = fetch_argv (simulator, PARM3);
1650 RETVAL = execve (path, argv, envp);
1651 free (path);
1652 freeargv (argv);
1653 freeargv (envp);
1654 RETERR = errno;
1655 break;
1656 }
1657 #endif
1658 #endif
1659
1660 #if HAVE_EXECV
1661 #ifdef TARGET_SYS_execv
1662 case TARGET_SYS_execv:
1663 {
1664 char *path = fetch_str (simulator, PARM1);
1665 char **argv = fetch_argv (simulator, PARM2);
1666 RETVAL = execv (path, argv);
1667 free (path);
1668 freeargv (argv);
1669 RETERR = errno;
1670 break;
1671 }
1672 #endif
1673 #endif
1674
1675 #if 0
1676 #ifdef TARGET_SYS_pipe
1677 case TARGET_SYS_pipe:
1678 {
1679 reg_t buf;
1680 int host_fd[2];
1681
1682 buf = PARM1;
1683 RETVAL = pipe (host_fd);
1684 SW (buf, host_fd[0]);
1685 buf += sizeof (uint16);
1686 SW (buf, host_fd[1]);
1687 RETERR = errno;
1688 }
1689 break;
1690 #endif
1691 #endif
1692
1693 #if 0
1694 #ifdef TARGET_SYS_wait
1695 case TARGET_SYS_wait:
1696 {
1697 int status;
1698
1699 RETVAL = wait (&status);
1700 SW (PARM1, status);
1701 RETERR = errno;
1702 }
1703 break;
1704 #endif
1705 #endif
1706
1707 #ifdef TARGET_SYS_read
1708 case TARGET_SYS_read:
1709 {
1710 char *buf = zalloc (PARM3);
1711 RETVAL = sim_io_read (simulator, PARM1, buf, PARM3);
1712 sim_write (simulator, PARM2, (unsigned char *) buf, PARM3);
1713 free (buf);
1714 if ((int) RETVAL < 0)
1715 RETERR = sim_io_get_errno (simulator);
1716 break;
1717 }
1718 #endif
1719
1720 #ifdef TARGET_SYS_write
1721 case TARGET_SYS_write:
1722 {
1723 char *buf = zalloc (PARM3);
1724 sim_read (simulator, PARM2, (unsigned char *) buf, PARM3);
1725 if (PARM1 == 1)
1726 RETVAL = sim_io_write_stdout (simulator, buf, PARM3);
1727 else
1728 RETVAL = sim_io_write (simulator, PARM1, buf, PARM3);
1729 free (buf);
1730 if ((int) RETVAL < 0)
1731 RETERR = sim_io_get_errno (simulator);
1732 break;
1733 }
1734 #endif
1735
1736 #ifdef TARGET_SYS_lseek
1737 case TARGET_SYS_lseek:
1738 RETVAL = sim_io_lseek (simulator, PARM1, PARM2, PARM3);
1739 if ((int) RETVAL < 0)
1740 RETERR = sim_io_get_errno (simulator);
1741 break;
1742 #endif
1743
1744 #ifdef TARGET_SYS_close
1745 case TARGET_SYS_close:
1746 RETVAL = sim_io_close (simulator, PARM1);
1747 if ((int) RETVAL < 0)
1748 RETERR = sim_io_get_errno (simulator);
1749 break;
1750 #endif
1751
1752 #ifdef TARGET_SYS_open
1753 case TARGET_SYS_open:
1754 {
1755 char *buf = fetch_str (simulator, PARM1);
1756 RETVAL = sim_io_open (simulator, buf, PARM2);
1757 free (buf);
1758 if ((int) RETVAL < 0)
1759 RETERR = sim_io_get_errno (simulator);
1760 break;
1761 }
1762 #endif
1763
1764 #ifdef TARGET_SYS_exit
1765 case TARGET_SYS_exit:
1766 if ((PARM1 & 0xffff0000) == 0xdead0000 && (PARM1 & 0xffff) != 0)
1767 /* get signal encoded by kill */
1768 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1769 sim_signalled, PARM1 & 0xffff);
1770 else if (PARM1 == 0xdead)
1771 /* old libraries */
1772 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1773 sim_stopped, SIM_SIGABRT);
1774 else
1775 /* PARM1 has exit status */
1776 sim_engine_halt (simulator, STATE_CPU (simulator, 0), NULL, PC,
1777 sim_exited, PARM1);
1778 break;
1779 #endif
1780
1781 #ifdef TARGET_SYS_stat
1782 case TARGET_SYS_stat: /* added at hmsi */
1783 /* stat system call */
1784 {
1785 struct stat host_stat;
1786 reg_t buf;
1787 char *path = fetch_str (simulator, PARM1);
1788
1789 RETVAL = sim_io_stat (simulator, path, &host_stat);
1790
1791 free (path);
1792 buf = PARM2;
1793
1794 /* Just wild-assed guesses. */
1795 store_mem (buf, 2, host_stat.st_dev);
1796 store_mem (buf + 2, 2, host_stat.st_ino);
1797 store_mem (buf + 4, 4, host_stat.st_mode);
1798 store_mem (buf + 8, 2, host_stat.st_nlink);
1799 store_mem (buf + 10, 2, host_stat.st_uid);
1800 store_mem (buf + 12, 2, host_stat.st_gid);
1801 store_mem (buf + 14, 2, host_stat.st_rdev);
1802 store_mem (buf + 16, 4, host_stat.st_size);
1803 store_mem (buf + 20, 4, host_stat.st_atime);
1804 store_mem (buf + 28, 4, host_stat.st_mtime);
1805 store_mem (buf + 36, 4, host_stat.st_ctime);
1806
1807 if ((int) RETVAL < 0)
1808 RETERR = sim_io_get_errno (simulator);
1809 }
1810 break;
1811 #endif
1812
1813 #ifdef TARGET_SYS_fstat
1814 case TARGET_SYS_fstat:
1815 /* fstat system call */
1816 {
1817 struct stat host_stat;
1818 reg_t buf;
1819
1820 RETVAL = sim_io_fstat (simulator, PARM1, &host_stat);
1821
1822 buf = PARM2;
1823
1824 /* Just wild-assed guesses. */
1825 store_mem (buf, 2, host_stat.st_dev);
1826 store_mem (buf + 2, 2, host_stat.st_ino);
1827 store_mem (buf + 4, 4, host_stat.st_mode);
1828 store_mem (buf + 8, 2, host_stat.st_nlink);
1829 store_mem (buf + 10, 2, host_stat.st_uid);
1830 store_mem (buf + 12, 2, host_stat.st_gid);
1831 store_mem (buf + 14, 2, host_stat.st_rdev);
1832 store_mem (buf + 16, 4, host_stat.st_size);
1833 store_mem (buf + 20, 4, host_stat.st_atime);
1834 store_mem (buf + 28, 4, host_stat.st_mtime);
1835 store_mem (buf + 36, 4, host_stat.st_ctime);
1836
1837 if ((int) RETVAL < 0)
1838 RETERR = sim_io_get_errno (simulator);
1839 }
1840 break;
1841 #endif
1842
1843 #ifdef TARGET_SYS_rename
1844 case TARGET_SYS_rename:
1845 {
1846 char *oldpath = fetch_str (simulator, PARM1);
1847 char *newpath = fetch_str (simulator, PARM2);
1848 RETVAL = sim_io_rename (simulator, oldpath, newpath);
1849 free (oldpath);
1850 free (newpath);
1851 if ((int) RETVAL < 0)
1852 RETERR = sim_io_get_errno (simulator);
1853 }
1854 break;
1855 #endif
1856
1857 #ifdef TARGET_SYS_unlink
1858 case TARGET_SYS_unlink:
1859 {
1860 char *path = fetch_str (simulator, PARM1);
1861 RETVAL = sim_io_unlink (simulator, path);
1862 free (path);
1863 if ((int) RETVAL < 0)
1864 RETERR = sim_io_get_errno (simulator);
1865 }
1866 break;
1867 #endif
1868
1869 #ifdef HAVE_CHOWN
1870 #ifdef TARGET_SYS_chown
1871 case TARGET_SYS_chown:
1872 {
1873 char *path = fetch_str (simulator, PARM1);
1874 RETVAL = chown (path, PARM2, PARM3);
1875 free (path);
1876 RETERR = errno;
1877 }
1878 break;
1879 #endif
1880 #endif
1881
1882 #if HAVE_CHMOD
1883 #ifdef TARGET_SYS_chmod
1884 case TARGET_SYS_chmod:
1885 {
1886 char *path = fetch_str (simulator, PARM1);
1887 RETVAL = chmod (path, PARM2);
1888 free (path);
1889 RETERR = errno;
1890 }
1891 break;
1892 #endif
1893 #endif
1894
1895 #ifdef TARGET_SYS_time
1896 #if HAVE_TIME
1897 case TARGET_SYS_time:
1898 {
1899 time_t now;
1900 RETVAL = time (&now);
1901 store_mem (PARM1, 4, now);
1902 RETERR = errno;
1903 }
1904 break;
1905 #endif
1906 #endif
1907
1908 #if !defined(__GO32__) && !defined(_WIN32)
1909 #ifdef TARGET_SYS_times
1910 case TARGET_SYS_times:
1911 {
1912 struct tms tms;
1913 RETVAL = times (&tms);
1914 store_mem (PARM1, 4, tms.tms_utime);
1915 store_mem (PARM1 + 4, 4, tms.tms_stime);
1916 store_mem (PARM1 + 8, 4, tms.tms_cutime);
1917 store_mem (PARM1 + 12, 4, tms.tms_cstime);
1918 reterr = errno;
1919 break;
1920 }
1921 #endif
1922 #endif
1923
1924 #ifdef TARGET_SYS_gettimeofday
1925 #if !defined(__GO32__) && !defined(_WIN32)
1926 case TARGET_SYS_gettimeofday:
1927 {
1928 struct timeval t;
1929 struct timezone tz;
1930 RETVAL = gettimeofday (&t, &tz);
1931 store_mem (PARM1, 4, t.tv_sec);
1932 store_mem (PARM1 + 4, 4, t.tv_usec);
1933 store_mem (PARM2, 4, tz.tz_minuteswest);
1934 store_mem (PARM2 + 4, 4, tz.tz_dsttime);
1935 RETERR = errno;
1936 break;
1937 }
1938 #endif
1939 #endif
1940
1941 #ifdef TARGET_SYS_utime
1942 #if HAVE_UTIME
1943 case TARGET_SYS_utime:
1944 {
1945 /* Cast the second argument to void *, to avoid type mismatch
1946 if a prototype is present. */
1947 sim_io_error (simulator, "Utime not supported");
1948 /* RETVAL = utime (path, (void *) MEMPTR (PARM2)); */
1949 }
1950 break;
1951 #endif
1952 #endif
1953
1954 default:
1955 abort ();
1956 }
1957 errno = save_errno;
1958
1959 return 4;
1960 }
1961 else
1962 { /* Trap 0 -> 30 */
1963 EIPC = PC + 4;
1964 EIPSW = PSW;
1965 /* Mask out EICC */
1966 ECR &= 0xffff0000;
1967 ECR |= 0x40 + OP[0];
1968 /* Flag that we are now doing exception processing. */
1969 PSW |= PSW_EP | PSW_ID;
1970 PC = (OP[0] < 0x10) ? 0x40 : 0x50;
1971
1972 return 0;
1973 }
1974 }
1975
1976 /* tst1 reg2, [reg1] */
1977 int
1978 OP_E607E0 (void)
1979 {
1980 int temp;
1981
1982 trace_input ("tst1", OP_BIT, 1);
1983
1984 temp = load_mem (State.regs[ OP[0] ], 1);
1985
1986 PSW &= ~PSW_Z;
1987 if ((temp & (1 << (State.regs[ OP[1] ] & 0x7))) == 0)
1988 PSW |= PSW_Z;
1989
1990 trace_output (OP_BIT);
1991
1992 return 4;
1993 }
1994
1995 /* mulu reg1, reg2, reg3 */
1996 int
1997 OP_22207E0 (void)
1998 {
1999 trace_input ("mulu", OP_REG_REG_REG, 0);
2000
2001 Multiply64 (0, State.regs[ OP[0] ]);
2002
2003 trace_output (OP_REG_REG_REG);
2004
2005 return 4;
2006 }
2007
2008 #define BIT_CHANGE_OP( name, binop ) \
2009 unsigned int bit; \
2010 unsigned int temp; \
2011 \
2012 trace_input (name, OP_BIT_CHANGE, 0); \
2013 \
2014 bit = 1 << (State.regs[ OP[1] ] & 0x7); \
2015 temp = load_mem (State.regs[ OP[0] ], 1); \
2016 \
2017 PSW &= ~PSW_Z; \
2018 if ((temp & bit) == 0) \
2019 PSW |= PSW_Z; \
2020 temp binop bit; \
2021 \
2022 store_mem (State.regs[ OP[0] ], 1, temp); \
2023 \
2024 trace_output (OP_BIT_CHANGE); \
2025 \
2026 return 4;
2027
2028 /* clr1 reg2, [reg1] */
2029 int
2030 OP_E407E0 (void)
2031 {
2032 BIT_CHANGE_OP ("clr1", &= ~ );
2033 }
2034
2035 /* not1 reg2, [reg1] */
2036 int
2037 OP_E207E0 (void)
2038 {
2039 BIT_CHANGE_OP ("not1", ^= );
2040 }
2041
2042 /* set1 */
2043 int
2044 OP_E007E0 (void)
2045 {
2046 BIT_CHANGE_OP ("set1", |= );
2047 }
2048
2049 /* sasf */
2050 int
2051 OP_20007E0 (void)
2052 {
2053 trace_input ("sasf", OP_EX1, 0);
2054
2055 State.regs[ OP[1] ] = (State.regs[ OP[1] ] << 1) | condition_met (OP[0]);
2056
2057 trace_output (OP_EX1);
2058
2059 return 4;
2060 }
2061
2062 /* This function is courtesy of Sugimoto at NEC, via Seow Tan
2063 (Soew_Tan@el.nec.com) */
2064 void
2065 divun
2066 (
2067 unsigned int N,
2068 unsigned long int als,
2069 unsigned long int sfi,
2070 unsigned32 /*unsigned long int*/ * quotient_ptr,
2071 unsigned32 /*unsigned long int*/ * remainder_ptr,
2072 int * overflow_ptr
2073 )
2074 {
2075 unsigned long ald = sfi >> (N - 1);
2076 unsigned long alo = als;
2077 unsigned int Q = 1;
2078 unsigned int C;
2079 unsigned int S = 0;
2080 unsigned int i;
2081 unsigned int R1 = 1;
2082 unsigned int DBZ = (als == 0) ? 1 : 0;
2083 unsigned long alt = Q ? ~als : als;
2084
2085 /* 1st Loop */
2086 alo = ald + alt + Q;
2087 C = (((alt >> 31) & (ald >> 31))
2088 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2089 C = C ^ Q;
2090 Q = ~(C ^ S) & 1;
2091 R1 = (alo == 0) ? 0 : (R1 & Q);
2092 if ((S ^ (alo>>31)) && !C)
2093 {
2094 DBZ = 1;
2095 }
2096 S = alo >> 31;
2097 sfi = (sfi << (32-N+1)) | Q;
2098 ald = (alo << 1) | (sfi >> 31);
2099
2100 /* 2nd - N-1th Loop */
2101 for (i = 2; i < N; i++)
2102 {
2103 alt = Q ? ~als : als;
2104 alo = ald + alt + Q;
2105 C = (((alt >> 31) & (ald >> 31))
2106 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2107 C = C ^ Q;
2108 Q = ~(C ^ S) & 1;
2109 R1 = (alo == 0) ? 0 : (R1 & Q);
2110 if ((S ^ (alo>>31)) && !C && !DBZ)
2111 {
2112 DBZ = 1;
2113 }
2114 S = alo >> 31;
2115 sfi = (sfi << 1) | Q;
2116 ald = (alo << 1) | (sfi >> 31);
2117 }
2118
2119 /* Nth Loop */
2120 alt = Q ? ~als : als;
2121 alo = ald + alt + Q;
2122 C = (((alt >> 31) & (ald >> 31))
2123 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2124 C = C ^ Q;
2125 Q = ~(C ^ S) & 1;
2126 R1 = (alo == 0) ? 0 : (R1 & Q);
2127 if ((S ^ (alo>>31)) && !C)
2128 {
2129 DBZ = 1;
2130 }
2131
2132 * quotient_ptr = (sfi << 1) | Q;
2133 * remainder_ptr = Q ? alo : (alo + als);
2134 * overflow_ptr = DBZ | R1;
2135 }
2136
2137 /* This function is courtesy of Sugimoto at NEC, via Seow Tan (Soew_Tan@el.nec.com) */
2138 void
2139 divn
2140 (
2141 unsigned int N,
2142 unsigned long int als,
2143 unsigned long int sfi,
2144 signed32 /*signed long int*/ * quotient_ptr,
2145 signed32 /*signed long int*/ * remainder_ptr,
2146 int * overflow_ptr
2147 )
2148 {
2149 unsigned long ald = (signed long) sfi >> (N - 1);
2150 unsigned long alo = als;
2151 unsigned int SS = als >> 31;
2152 unsigned int SD = sfi >> 31;
2153 unsigned int R1 = 1;
2154 unsigned int OV;
2155 unsigned int DBZ = als == 0 ? 1 : 0;
2156 unsigned int Q = ~(SS ^ SD) & 1;
2157 unsigned int C;
2158 unsigned int S;
2159 unsigned int i;
2160 unsigned long alt = Q ? ~als : als;
2161
2162
2163 /* 1st Loop */
2164
2165 alo = ald + alt + Q;
2166 C = (((alt >> 31) & (ald >> 31))
2167 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2168 Q = C ^ SS;
2169 R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2170 S = alo >> 31;
2171 sfi = (sfi << (32-N+1)) | Q;
2172 ald = (alo << 1) | (sfi >> 31);
2173 if ((alo >> 31) ^ (ald >> 31))
2174 {
2175 DBZ = 1;
2176 }
2177
2178 /* 2nd - N-1th Loop */
2179
2180 for (i = 2; i < N; i++)
2181 {
2182 alt = Q ? ~als : als;
2183 alo = ald + alt + Q;
2184 C = (((alt >> 31) & (ald >> 31))
2185 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2186 Q = C ^ SS;
2187 R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2188 S = alo >> 31;
2189 sfi = (sfi << 1) | Q;
2190 ald = (alo << 1) | (sfi >> 31);
2191 if ((alo >> 31) ^ (ald >> 31))
2192 {
2193 DBZ = 1;
2194 }
2195 }
2196
2197 /* Nth Loop */
2198 alt = Q ? ~als : als;
2199 alo = ald + alt + Q;
2200 C = (((alt >> 31) & (ald >> 31))
2201 | (((alt >> 31) ^ (ald >> 31)) & (~alo >> 31)));
2202 Q = C ^ SS;
2203 R1 = (alo == 0) ? 0 : (R1 & (Q ^ (SS ^ SD)));
2204 sfi = (sfi << (32-N+1));
2205 ald = alo;
2206
2207 /* End */
2208 if (alo != 0)
2209 {
2210 alt = Q ? ~als : als;
2211 alo = ald + alt + Q;
2212 }
2213 R1 = R1 & ((~alo >> 31) ^ SD);
2214 if ((alo != 0) && ((Q ^ (SS ^ SD)) ^ R1)) alo = ald;
2215 if (N != 32)
2216 ald = sfi = (long) ((sfi >> 1) | (SS ^ SD) << 31) >> (32-N-1) | Q;
2217 else
2218 ald = sfi = sfi | Q;
2219
2220 OV = DBZ | ((alo == 0) ? 0 : R1);
2221
2222 * remainder_ptr = alo;
2223
2224 /* Adj */
2225 if (((alo != 0) && ((SS ^ SD) ^ R1))
2226 || ((alo == 0) && (SS ^ R1)))
2227 alo = ald + 1;
2228 else
2229 alo = ald;
2230
2231 OV = (DBZ | R1) ? OV : ((alo >> 31) & (~ald >> 31));
2232
2233 * quotient_ptr = alo;
2234 * overflow_ptr = OV;
2235 }
2236
2237 /* sdivun imm5, reg1, reg2, reg3 */
2238 int
2239 OP_1C207E0 (void)
2240 {
2241 unsigned32 /*unsigned long int*/ quotient;
2242 unsigned32 /*unsigned long int*/ remainder;
2243 unsigned long int divide_by;
2244 unsigned long int divide_this;
2245 int overflow = 0;
2246 unsigned int imm5;
2247
2248 trace_input ("sdivun", OP_IMM_REG_REG_REG, 0);
2249
2250 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2251
2252 divide_by = State.regs[ OP[0] ];
2253 divide_this = State.regs[ OP[1] ] << imm5;
2254
2255 divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2256
2257 State.regs[ OP[1] ] = quotient;
2258 State.regs[ OP[2] >> 11 ] = remainder;
2259
2260 /* Set condition codes. */
2261 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2262
2263 if (overflow) PSW |= PSW_OV;
2264 if (quotient == 0) PSW |= PSW_Z;
2265 if (quotient & 0x80000000) PSW |= PSW_S;
2266
2267 trace_output (OP_IMM_REG_REG_REG);
2268
2269 return 4;
2270 }
2271
2272 /* sdivn imm5, reg1, reg2, reg3 */
2273 int
2274 OP_1C007E0 (void)
2275 {
2276 signed32 /*signed long int*/ quotient;
2277 signed32 /*signed long int*/ remainder;
2278 signed long int divide_by;
2279 signed long int divide_this;
2280 int overflow = 0;
2281 unsigned int imm5;
2282
2283 trace_input ("sdivn", OP_IMM_REG_REG_REG, 0);
2284
2285 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2286
2287 divide_by = (signed32) State.regs[ OP[0] ];
2288 divide_this = (signed32) (State.regs[ OP[1] ] << imm5);
2289
2290 divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2291
2292 State.regs[ OP[1] ] = quotient;
2293 State.regs[ OP[2] >> 11 ] = remainder;
2294
2295 /* Set condition codes. */
2296 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2297
2298 if (overflow) PSW |= PSW_OV;
2299 if (quotient == 0) PSW |= PSW_Z;
2300 if (quotient < 0) PSW |= PSW_S;
2301
2302 trace_output (OP_IMM_REG_REG_REG);
2303
2304 return 4;
2305 }
2306
2307 /* sdivhun imm5, reg1, reg2, reg3 */
2308 int
2309 OP_18207E0 (void)
2310 {
2311 unsigned32 /*unsigned long int*/ quotient;
2312 unsigned32 /*unsigned long int*/ remainder;
2313 unsigned long int divide_by;
2314 unsigned long int divide_this;
2315 int overflow = 0;
2316 unsigned int imm5;
2317
2318 trace_input ("sdivhun", OP_IMM_REG_REG_REG, 0);
2319
2320 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2321
2322 divide_by = State.regs[ OP[0] ] & 0xffff;
2323 divide_this = State.regs[ OP[1] ] << imm5;
2324
2325 divun (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2326
2327 State.regs[ OP[1] ] = quotient;
2328 State.regs[ OP[2] >> 11 ] = remainder;
2329
2330 /* Set condition codes. */
2331 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2332
2333 if (overflow) PSW |= PSW_OV;
2334 if (quotient == 0) PSW |= PSW_Z;
2335 if (quotient & 0x80000000) PSW |= PSW_S;
2336
2337 trace_output (OP_IMM_REG_REG_REG);
2338
2339 return 4;
2340 }
2341
2342 /* sdivhn imm5, reg1, reg2, reg3 */
2343 int
2344 OP_18007E0 (void)
2345 {
2346 signed32 /*signed long int*/ quotient;
2347 signed32 /*signed long int*/ remainder;
2348 signed long int divide_by;
2349 signed long int divide_this;
2350 int overflow = 0;
2351 unsigned int imm5;
2352
2353 trace_input ("sdivhn", OP_IMM_REG_REG_REG, 0);
2354
2355 imm5 = 32 - ((OP[3] & 0x3c0000) >> 17);
2356
2357 divide_by = EXTEND16 (State.regs[ OP[0] ]);
2358 divide_this = (signed32) (State.regs[ OP[1] ] << imm5);
2359
2360 divn (imm5, divide_by, divide_this, & quotient, & remainder, & overflow);
2361
2362 State.regs[ OP[1] ] = quotient;
2363 State.regs[ OP[2] >> 11 ] = remainder;
2364
2365 /* Set condition codes. */
2366 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2367
2368 if (overflow) PSW |= PSW_OV;
2369 if (quotient == 0) PSW |= PSW_Z;
2370 if (quotient < 0) PSW |= PSW_S;
2371
2372 trace_output (OP_IMM_REG_REG_REG);
2373
2374 return 4;
2375 }
2376
2377 /* divu reg1, reg2, reg3 */
2378 int
2379 OP_2C207E0 (void)
2380 {
2381 unsigned long int quotient;
2382 unsigned long int remainder;
2383 unsigned long int divide_by;
2384 unsigned long int divide_this;
2385 int overflow = 0;
2386
2387 trace_input ("divu", OP_REG_REG_REG, 0);
2388
2389 /* Compute the result. */
2390
2391 divide_by = State.regs[ OP[0] ];
2392 divide_this = State.regs[ OP[1] ];
2393
2394 if (divide_by == 0)
2395 {
2396 PSW |= PSW_OV;
2397 }
2398 else
2399 {
2400 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2401 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2402
2403 /* Set condition codes. */
2404 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2405
2406 if (overflow) PSW |= PSW_OV;
2407 if (quotient == 0) PSW |= PSW_Z;
2408 if (quotient & 0x80000000) PSW |= PSW_S;
2409 }
2410
2411 trace_output (OP_REG_REG_REG);
2412
2413 return 4;
2414 }
2415
2416 /* div reg1, reg2, reg3 */
2417 int
2418 OP_2C007E0 (void)
2419 {
2420 signed long int quotient;
2421 signed long int remainder;
2422 signed long int divide_by;
2423 signed long int divide_this;
2424
2425 trace_input ("div", OP_REG_REG_REG, 0);
2426
2427 /* Compute the result. */
2428
2429 divide_by = (signed32) State.regs[ OP[0] ];
2430 divide_this = State.regs[ OP[1] ];
2431
2432 if (divide_by == 0)
2433 {
2434 PSW |= PSW_OV;
2435 }
2436 else if (divide_by == -1 && divide_this == (1L << 31))
2437 {
2438 PSW &= ~PSW_Z;
2439 PSW |= PSW_OV | PSW_S;
2440 State.regs[ OP[1] ] = (1 << 31);
2441 State.regs[ OP[2] >> 11 ] = 0;
2442 }
2443 else
2444 {
2445 divide_this = (signed32) divide_this;
2446 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2447 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2448
2449 /* Set condition codes. */
2450 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2451
2452 if (quotient == 0) PSW |= PSW_Z;
2453 if (quotient < 0) PSW |= PSW_S;
2454 }
2455
2456 trace_output (OP_REG_REG_REG);
2457
2458 return 4;
2459 }
2460
2461 /* divhu reg1, reg2, reg3 */
2462 int
2463 OP_28207E0 (void)
2464 {
2465 unsigned long int quotient;
2466 unsigned long int remainder;
2467 unsigned long int divide_by;
2468 unsigned long int divide_this;
2469 int overflow = 0;
2470
2471 trace_input ("divhu", OP_REG_REG_REG, 0);
2472
2473 /* Compute the result. */
2474
2475 divide_by = State.regs[ OP[0] ] & 0xffff;
2476 divide_this = State.regs[ OP[1] ];
2477
2478 if (divide_by == 0)
2479 {
2480 PSW |= PSW_OV;
2481 }
2482 else
2483 {
2484 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2485 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2486
2487 /* Set condition codes. */
2488 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2489
2490 if (overflow) PSW |= PSW_OV;
2491 if (quotient == 0) PSW |= PSW_Z;
2492 if (quotient & 0x80000000) PSW |= PSW_S;
2493 }
2494
2495 trace_output (OP_REG_REG_REG);
2496
2497 return 4;
2498 }
2499
2500 /* divh reg1, reg2, reg3 */
2501 int
2502 OP_28007E0 (void)
2503 {
2504 signed long int quotient;
2505 signed long int remainder;
2506 signed long int divide_by;
2507 signed long int divide_this;
2508 int overflow = 0;
2509
2510 trace_input ("divh", OP_REG_REG_REG, 0);
2511
2512 /* Compute the result. */
2513
2514 divide_by = EXTEND16 (State.regs[ OP[0] ]);
2515 divide_this = State.regs[ OP[1] ];
2516
2517 if (divide_by == 0)
2518 {
2519 PSW |= PSW_OV;
2520 }
2521 else if (divide_by == -1 && divide_this == (1L << 31))
2522 {
2523 PSW &= ~PSW_Z;
2524 PSW |= PSW_OV | PSW_S;
2525 State.regs[ OP[1] ] = (1 << 31);
2526 State.regs[ OP[2] >> 11 ] = 0;
2527 }
2528 else
2529 {
2530 divide_this = (signed32) divide_this;
2531 State.regs[ OP[1] ] = quotient = divide_this / divide_by;
2532 State.regs[ OP[2] >> 11 ] = remainder = divide_this % divide_by;
2533
2534 /* Set condition codes. */
2535 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
2536
2537 if (quotient == 0) PSW |= PSW_Z;
2538 if (quotient < 0) PSW |= PSW_S;
2539 }
2540
2541 trace_output (OP_REG_REG_REG);
2542
2543 return 4;
2544 }
2545
2546 /* mulu imm9, reg2, reg3 */
2547 int
2548 OP_24207E0 (void)
2549 {
2550 trace_input ("mulu", OP_IMM_REG_REG, 0);
2551
2552 Multiply64 (0, (OP[3] & 0x1f) | ((OP[3] >> 13) & 0x1e0));
2553
2554 trace_output (OP_IMM_REG_REG);
2555
2556 return 4;
2557 }
2558
2559 /* mul imm9, reg2, reg3 */
2560 int
2561 OP_24007E0 (void)
2562 {
2563 trace_input ("mul", OP_IMM_REG_REG, 0);
2564
2565 Multiply64 (1, SEXT9 ((OP[3] & 0x1f) | ((OP[3] >> 13) & 0x1e0)));
2566
2567 trace_output (OP_IMM_REG_REG);
2568
2569 return 4;
2570 }
2571
2572 /* ld.hu */
2573 int
2574 OP_107E0 (void)
2575 {
2576 int adr;
2577
2578 trace_input ("ld.hu", OP_LOAD32, 2);
2579
2580 adr = State.regs[ OP[0] ] + EXTEND16 (OP[2] & ~1);
2581 adr &= ~0x1;
2582
2583 State.regs[ OP[1] ] = load_mem (adr, 2);
2584
2585 trace_output (OP_LOAD32);
2586
2587 return 4;
2588 }
2589
2590
2591 /* ld.bu */
2592 int
2593 OP_10780 (void)
2594 {
2595 int adr;
2596
2597 trace_input ("ld.bu", OP_LOAD32, 1);
2598
2599 adr = (State.regs[ OP[0] ]
2600 + (EXTEND16 (OP[2] & ~1) | ((OP[3] >> 5) & 1)));
2601
2602 State.regs[ OP[1] ] = load_mem (adr, 1);
2603
2604 trace_output (OP_LOAD32);
2605
2606 return 4;
2607 }
2608
2609 /* prepare list12, imm5, imm32 */
2610 int
2611 OP_1B0780 (void)
2612 {
2613 int i;
2614
2615 trace_input ("prepare", OP_PUSHPOP1, 0);
2616
2617 /* Store the registers with lower number registers being placed at higher addresses. */
2618 for (i = 0; i < 12; i++)
2619 if ((OP[3] & (1 << type1_regs[ i ])))
2620 {
2621 SP -= 4;
2622 store_mem (SP, 4, State.regs[ 20 + i ]);
2623 }
2624
2625 SP -= (OP[3] & 0x3e) << 1;
2626
2627 EP = load_mem (PC + 4, 4);
2628
2629 trace_output (OP_PUSHPOP1);
2630
2631 return 8;
2632 }
2633
2634 /* prepare list12, imm5, imm16-32 */
2635 int
2636 OP_130780 (void)
2637 {
2638 int i;
2639
2640 trace_input ("prepare", OP_PUSHPOP1, 0);
2641
2642 /* Store the registers with lower number registers being placed at higher addresses. */
2643 for (i = 0; i < 12; i++)
2644 if ((OP[3] & (1 << type1_regs[ i ])))
2645 {
2646 SP -= 4;
2647 store_mem (SP, 4, State.regs[ 20 + i ]);
2648 }
2649
2650 SP -= (OP[3] & 0x3e) << 1;
2651
2652 EP = load_mem (PC + 4, 2) << 16;
2653
2654 trace_output (OP_PUSHPOP1);
2655
2656 return 6;
2657 }
2658
2659 /* prepare list12, imm5, imm16 */
2660 int
2661 OP_B0780 (void)
2662 {
2663 int i;
2664
2665 trace_input ("prepare", OP_PUSHPOP1, 0);
2666
2667 /* Store the registers with lower number registers being placed at higher addresses. */
2668 for (i = 0; i < 12; i++)
2669 if ((OP[3] & (1 << type1_regs[ i ])))
2670 {
2671 SP -= 4;
2672 store_mem (SP, 4, State.regs[ 20 + i ]);
2673 }
2674
2675 SP -= (OP[3] & 0x3e) << 1;
2676
2677 EP = EXTEND16 (load_mem (PC + 4, 2));
2678
2679 trace_output (OP_PUSHPOP1);
2680
2681 return 6;
2682 }
2683
2684 /* prepare list12, imm5, sp */
2685 int
2686 OP_30780 (void)
2687 {
2688 int i;
2689
2690 trace_input ("prepare", OP_PUSHPOP1, 0);
2691
2692 /* Store the registers with lower number registers being placed at higher addresses. */
2693 for (i = 0; i < 12; i++)
2694 if ((OP[3] & (1 << type1_regs[ i ])))
2695 {
2696 SP -= 4;
2697 store_mem (SP, 4, State.regs[ 20 + i ]);
2698 }
2699
2700 SP -= (OP[3] & 0x3e) << 1;
2701
2702 EP = SP;
2703
2704 trace_output (OP_PUSHPOP1);
2705
2706 return 4;
2707 }
2708
2709 /* mul reg1, reg2, reg3 */
2710 int
2711 OP_22007E0 (void)
2712 {
2713 trace_input ("mul", OP_REG_REG_REG, 0);
2714
2715 Multiply64 (1, State.regs[ OP[0] ]);
2716
2717 trace_output (OP_REG_REG_REG);
2718
2719 return 4;
2720 }
2721
2722 /* popmh list18 */
2723 int
2724 OP_307F0 (void)
2725 {
2726 int i;
2727
2728 trace_input ("popmh", OP_PUSHPOP2, 0);
2729
2730 if (OP[3] & (1 << 19))
2731 {
2732 if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
2733 {
2734 FEPSW = load_mem ( SP & ~ 3, 4);
2735 FEPC = load_mem ((SP + 4) & ~ 3, 4);
2736 }
2737 else
2738 {
2739 EIPSW = load_mem ( SP & ~ 3, 4);
2740 EIPC = load_mem ((SP + 4) & ~ 3, 4);
2741 }
2742
2743 SP += 8;
2744 }
2745
2746 /* Load the registers with lower number registers being retrieved from higher addresses. */
2747 for (i = 16; i--;)
2748 if ((OP[3] & (1 << type2_regs[ i ])))
2749 {
2750 State.regs[ i + 16 ] = load_mem (SP & ~ 3, 4);
2751 SP += 4;
2752 }
2753
2754 trace_output (OP_PUSHPOP2);
2755
2756 return 4;
2757 }
2758
2759 /* popml lsit18 */
2760 int
2761 OP_107F0 (void)
2762 {
2763 int i;
2764
2765 trace_input ("popml", OP_PUSHPOP3, 0);
2766
2767 if (OP[3] & (1 << 19))
2768 {
2769 if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
2770 {
2771 FEPSW = load_mem ( SP & ~ 3, 4);
2772 FEPC = load_mem ((SP + 4) & ~ 3, 4);
2773 }
2774 else
2775 {
2776 EIPSW = load_mem ( SP & ~ 3, 4);
2777 EIPC = load_mem ((SP + 4) & ~ 3, 4);
2778 }
2779
2780 SP += 8;
2781 }
2782
2783 if (OP[3] & (1 << 3))
2784 {
2785 PSW = load_mem (SP & ~ 3, 4);
2786 SP += 4;
2787 }
2788
2789 /* Load the registers with lower number registers being retrieved from higher addresses. */
2790 for (i = 15; i--;)
2791 if ((OP[3] & (1 << type3_regs[ i ])))
2792 {
2793 State.regs[ i + 1 ] = load_mem (SP & ~ 3, 4);
2794 SP += 4;
2795 }
2796
2797 trace_output (OP_PUSHPOP2);
2798
2799 return 4;
2800 }
2801
2802 /* pushmh list18 */
2803 int
2804 OP_307E0 (void)
2805 {
2806 int i;
2807
2808 trace_input ("pushmh", OP_PUSHPOP2, 0);
2809
2810 /* Store the registers with lower number registers being placed at higher addresses. */
2811 for (i = 0; i < 16; i++)
2812 if ((OP[3] & (1 << type2_regs[ i ])))
2813 {
2814 SP -= 4;
2815 store_mem (SP & ~ 3, 4, State.regs[ i + 16 ]);
2816 }
2817
2818 if (OP[3] & (1 << 19))
2819 {
2820 SP -= 8;
2821
2822 if ((PSW & PSW_NP) && ((PSW & PSW_EP) == 0))
2823 {
2824 store_mem ((SP + 4) & ~ 3, 4, FEPC);
2825 store_mem ( SP & ~ 3, 4, FEPSW);
2826 }
2827 else
2828 {
2829 store_mem ((SP + 4) & ~ 3, 4, EIPC);
2830 store_mem ( SP & ~ 3, 4, EIPSW);
2831 }
2832 }
2833
2834 trace_output (OP_PUSHPOP2);
2835
2836 return 4;
2837 }
2838
2839 /* V850E2R FPU functions */
2840 /*
2841 sim_fpu_status_invalid_snan = 1, -V--- (sim spec.)
2842 sim_fpu_status_invalid_qnan = 2, ----- (sim spec.)
2843 sim_fpu_status_invalid_isi = 4, (inf - inf) -V---
2844 sim_fpu_status_invalid_idi = 8, (inf / inf) -V---
2845 sim_fpu_status_invalid_zdz = 16, (0 / 0) -V---
2846 sim_fpu_status_invalid_imz = 32, (inf * 0) -V---
2847 sim_fpu_status_invalid_cvi = 64, convert to integer -V---
2848 sim_fpu_status_invalid_div0 = 128, (X / 0) --Z--
2849 sim_fpu_status_invalid_cmp = 256, compare ----- (sim spec.)
2850 sim_fpu_status_invalid_sqrt = 512, -V---
2851 sim_fpu_status_rounded = 1024, I----
2852 sim_fpu_status_inexact = 2048, I---- (sim spec.)
2853 sim_fpu_status_overflow = 4096, I--O-
2854 sim_fpu_status_underflow = 8192, I---U
2855 sim_fpu_status_denorm = 16384, ----U (sim spec.)
2856 */
2857
2858 void
2859 update_fpsr (SIM_DESC sd, sim_fpu_status status, unsigned int mask, unsigned int double_op_p)
2860 {
2861 unsigned int fpsr = FPSR & mask;
2862
2863 unsigned int flags = 0;
2864
2865 if (fpsr & FPSR_XEI
2866 && ((status & (sim_fpu_status_rounded
2867 | sim_fpu_status_overflow
2868 | sim_fpu_status_inexact))
2869 || (status & sim_fpu_status_underflow
2870 && (fpsr & (FPSR_XEU | FPSR_XEI)) == 0
2871 && fpsr & FPSR_FS)))
2872 {
2873 flags |= FPSR_XCI | FPSR_XPI;
2874 }
2875
2876 if (fpsr & FPSR_XEV
2877 && (status & (sim_fpu_status_invalid_isi
2878 | sim_fpu_status_invalid_imz
2879 | sim_fpu_status_invalid_zdz
2880 | sim_fpu_status_invalid_idi
2881 | sim_fpu_status_invalid_cvi
2882 | sim_fpu_status_invalid_sqrt
2883 | sim_fpu_status_invalid_snan)))
2884 {
2885 flags |= FPSR_XCV | FPSR_XPV;
2886 }
2887
2888 if (fpsr & FPSR_XEZ
2889 && (status & sim_fpu_status_invalid_div0))
2890 {
2891 flags |= FPSR_XCV | FPSR_XPV;
2892 }
2893
2894 if (fpsr & FPSR_XEO
2895 && (status & sim_fpu_status_overflow))
2896 {
2897 flags |= FPSR_XCO | FPSR_XPO;
2898 }
2899
2900 if (((fpsr & FPSR_XEU) || (fpsr & FPSR_FS) == 0)
2901 && (status & (sim_fpu_status_underflow
2902 | sim_fpu_status_denorm)))
2903 {
2904 flags |= FPSR_XCU | FPSR_XPU;
2905 }
2906
2907 if (flags)
2908 {
2909 FPSR &= ~FPSR_XC;
2910 FPSR |= flags;
2911
2912 SignalExceptionFPE (sd, double_op_p);
2913 }
2914 }
2915
2916 /* Exception. */
2917
2918 void
2919 SignalException (SIM_DESC sd)
2920 {
2921 if (MPM & MPM_AUE)
2922 {
2923 PSW = PSW & ~(PSW_NPV | PSW_DMP | PSW_IMP);
2924 }
2925 }
2926
2927 void
2928 SignalExceptionFPE (SIM_DESC sd, unsigned int double_op_p)
2929 {
2930 if (((PSW & (PSW_NP|PSW_ID)) == 0)
2931 || !(FPSR & (double_op_p ? FPSR_DEM : FPSR_SEM)))
2932 {
2933 EIPC = PC;
2934 EIPSW = PSW;
2935 EIIC = (FPSR & (double_op_p ? FPSR_DEM : FPSR_SEM))
2936 ? 0x71 : 0x72;
2937 PSW |= (PSW_EP | PSW_ID);
2938 PC = 0x70;
2939
2940 SignalException (sd);
2941 }
2942 }
2943
2944 void
2945 check_invalid_snan (SIM_DESC sd, sim_fpu_status status, unsigned int double_op_p)
2946 {
2947 if ((FPSR & FPSR_XEI)
2948 && (status & sim_fpu_status_invalid_snan))
2949 {
2950 FPSR &= ~FPSR_XC;
2951 FPSR |= FPSR_XCV;
2952 FPSR |= FPSR_XPV;
2953 SignalExceptionFPE (sd, double_op_p);
2954 }
2955 }
2956
2957 int
2958 v850_float_compare (SIM_DESC sd, int cmp, sim_fpu wop1, sim_fpu wop2, int double_op_p)
2959 {
2960 int result = -1;
2961
2962 if (sim_fpu_is_nan (&wop1) || sim_fpu_is_nan (&wop2))
2963 {
2964 if (cmp & 0x8)
2965 {
2966 if (FPSR & FPSR_XEV)
2967 {
2968 FPSR |= FPSR_XCV | FPSR_XPV;
2969 SignalExceptionFPE (sd, double_op_p);
2970 }
2971 }
2972
2973 switch (cmp)
2974 {
2975 case FPU_CMP_F:
2976 result = 0;
2977 break;
2978 case FPU_CMP_UN:
2979 result = 1;
2980 break;
2981 case FPU_CMP_EQ:
2982 result = 0;
2983 break;
2984 case FPU_CMP_UEQ:
2985 result = 1;
2986 break;
2987 case FPU_CMP_OLT:
2988 result = 0;
2989 break;
2990 case FPU_CMP_ULT:
2991 result = 1;
2992 break;
2993 case FPU_CMP_OLE:
2994 result = 0;
2995 break;
2996 case FPU_CMP_ULE:
2997 result = 1;
2998 break;
2999 case FPU_CMP_SF:
3000 result = 0;
3001 break;
3002 case FPU_CMP_NGLE:
3003 result = 1;
3004 break;
3005 case FPU_CMP_SEQ:
3006 result = 0;
3007 break;
3008 case FPU_CMP_NGL:
3009 result = 1;
3010 break;
3011 case FPU_CMP_LT:
3012 result = 0;
3013 break;
3014 case FPU_CMP_NGE:
3015 result = 1;
3016 break;
3017 case FPU_CMP_LE:
3018 result = 0;
3019 break;
3020 case FPU_CMP_NGT:
3021 result = 1;
3022 break;
3023 default:
3024 abort ();
3025 }
3026 }
3027 else if (sim_fpu_is_infinity (&wop1) && sim_fpu_is_infinity (&wop2)
3028 && sim_fpu_sign (&wop1) == sim_fpu_sign (&wop2))
3029 {
3030 switch (cmp)
3031 {
3032 case FPU_CMP_F:
3033 result = 0;
3034 break;
3035 case FPU_CMP_UN:
3036 result = 0;
3037 break;
3038 case FPU_CMP_EQ:
3039 result = 1;
3040 break;
3041 case FPU_CMP_UEQ:
3042 result = 1;
3043 break;
3044 case FPU_CMP_OLT:
3045 result = 0;
3046 break;
3047 case FPU_CMP_ULT:
3048 result = 0;
3049 break;
3050 case FPU_CMP_OLE:
3051 result = 1;
3052 break;
3053 case FPU_CMP_ULE:
3054 result = 1;
3055 break;
3056 case FPU_CMP_SF:
3057 result = 0;
3058 break;
3059 case FPU_CMP_NGLE:
3060 result = 0;
3061 break;
3062 case FPU_CMP_SEQ:
3063 result = 1;
3064 break;
3065 case FPU_CMP_NGL:
3066 result = 1;
3067 break;
3068 case FPU_CMP_LT:
3069 result = 0;
3070 break;
3071 case FPU_CMP_NGE:
3072 result = 0;
3073 break;
3074 case FPU_CMP_LE:
3075 result = 1;
3076 break;
3077 case FPU_CMP_NGT:
3078 result = 1;
3079 break;
3080 default:
3081 abort ();
3082 }
3083 }
3084 else
3085 {
3086 int gt = 0,lt = 0,eq = 0, status;
3087
3088 status = sim_fpu_cmp (&wop1, &wop2);
3089
3090 switch (status)
3091 {
3092 case SIM_FPU_IS_SNAN:
3093 case SIM_FPU_IS_QNAN:
3094 abort ();
3095 break;
3096
3097 case SIM_FPU_IS_NINF:
3098 lt = 1;
3099 break;
3100 case SIM_FPU_IS_PINF:
3101 gt = 1;
3102 break;
3103 case SIM_FPU_IS_NNUMBER:
3104 lt = 1;
3105 break;
3106 case SIM_FPU_IS_PNUMBER:
3107 gt = 1;
3108 break;
3109 case SIM_FPU_IS_NDENORM:
3110 lt = 1;
3111 break;
3112 case SIM_FPU_IS_PDENORM:
3113 gt = 1;
3114 break;
3115 case SIM_FPU_IS_NZERO:
3116 case SIM_FPU_IS_PZERO:
3117 eq = 1;
3118 break;
3119 }
3120
3121 switch (cmp)
3122 {
3123 case FPU_CMP_F:
3124 result = 0;
3125 break;
3126 case FPU_CMP_UN:
3127 result = 0;
3128 break;
3129 case FPU_CMP_EQ:
3130 result = eq;
3131 break;
3132 case FPU_CMP_UEQ:
3133 result = eq;
3134 break;
3135 case FPU_CMP_OLT:
3136 result = lt;
3137 break;
3138 case FPU_CMP_ULT:
3139 result = lt;
3140 break;
3141 case FPU_CMP_OLE:
3142 result = lt || eq;
3143 break;
3144 case FPU_CMP_ULE:
3145 result = lt || eq;
3146 break;
3147 case FPU_CMP_SF:
3148 result = 0;
3149 break;
3150 case FPU_CMP_NGLE:
3151 result = 0;
3152 break;
3153 case FPU_CMP_SEQ:
3154 result = eq;
3155 break;
3156 case FPU_CMP_NGL:
3157 result = eq;
3158 break;
3159 case FPU_CMP_LT:
3160 result = lt;
3161 break;
3162 case FPU_CMP_NGE:
3163 result = lt;
3164 break;
3165 case FPU_CMP_LE:
3166 result = lt || eq;
3167 break;
3168 case FPU_CMP_NGT:
3169 result = lt || eq;
3170 break;
3171 }
3172 }
3173
3174 ASSERT (result != -1);
3175 return result;
3176 }
3177
3178 void
3179 v850_div (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p, unsigned int *op3p)
3180 {
3181 signed long int quotient;
3182 signed long int remainder;
3183 signed long int divide_by;
3184 signed long int divide_this;
3185 bfd_boolean overflow = FALSE;
3186
3187 /* Compute the result. */
3188 divide_by = op0;
3189 divide_this = op1;
3190
3191 if (divide_by == 0 || (divide_by == -1 && divide_this == (1 << 31)))
3192 {
3193 overflow = TRUE;
3194 divide_by = 1;
3195 }
3196
3197 quotient = divide_this / divide_by;
3198 remainder = divide_this % divide_by;
3199
3200 /* Set condition codes. */
3201 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
3202
3203 if (overflow) PSW |= PSW_OV;
3204 if (quotient == 0) PSW |= PSW_Z;
3205 if (quotient < 0) PSW |= PSW_S;
3206
3207 *op2p = quotient;
3208 *op3p = remainder;
3209 }
3210
3211 void
3212 v850_divu (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p, unsigned int *op3p)
3213 {
3214 unsigned long int quotient;
3215 unsigned long int remainder;
3216 unsigned long int divide_by;
3217 unsigned long int divide_this;
3218 bfd_boolean overflow = FALSE;
3219
3220 /* Compute the result. */
3221
3222 divide_by = op0;
3223 divide_this = op1;
3224
3225 if (divide_by == 0)
3226 {
3227 overflow = TRUE;
3228 divide_by = 1;
3229 }
3230
3231 quotient = divide_this / divide_by;
3232 remainder = divide_this % divide_by;
3233
3234 /* Set condition codes. */
3235 PSW &= ~(PSW_Z | PSW_S | PSW_OV);
3236
3237 if (overflow) PSW |= PSW_OV;
3238 if (quotient == 0) PSW |= PSW_Z;
3239 if (quotient & 0x80000000) PSW |= PSW_S;
3240
3241 *op2p = quotient;
3242 *op3p = remainder;
3243 }
3244
3245 void
3246 v850_sar (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p)
3247 {
3248 unsigned int result, z, s, cy;
3249
3250 op0 &= 0x1f;
3251 result = (signed)op1 >> op0;
3252
3253 /* Compute the condition codes. */
3254 z = (result == 0);
3255 s = (result & 0x80000000);
3256 cy = (op1 & (1 << (op0 - 1)));
3257
3258 /* Store the result and condition codes. */
3259 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
3260 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
3261 | (cy ? PSW_CY : 0));
3262
3263 *op2p = result;
3264 }
3265
3266 void
3267 v850_shl (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p)
3268 {
3269 unsigned int result, z, s, cy;
3270
3271 op0 &= 0x1f;
3272 result = op1 << op0;
3273
3274 /* Compute the condition codes. */
3275 z = (result == 0);
3276 s = (result & 0x80000000);
3277 cy = (op1 & (1 << (32 - op0)));
3278
3279 /* Store the result and condition codes. */
3280 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
3281 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
3282 | (cy ? PSW_CY : 0));
3283
3284 *op2p = result;
3285 }
3286
3287 void
3288 v850_rotl (SIM_DESC sd, unsigned int amount, unsigned int src, unsigned int * dest)
3289 {
3290 unsigned int result, z, s, cy;
3291
3292 amount &= 0x1f;
3293 result = src << amount;
3294 result |= src >> (32 - amount);
3295
3296 /* Compute the condition codes. */
3297 z = (result == 0);
3298 s = (result & 0x80000000);
3299 cy = ! (result & 1);
3300
3301 /* Store the result and condition codes. */
3302 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
3303 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
3304 | (cy ? PSW_CY : 0));
3305
3306 * dest = result;
3307 }
3308
3309 void
3310 v850_bins (SIM_DESC sd, unsigned int source, unsigned int lsb, unsigned int msb,
3311 unsigned int * dest)
3312 {
3313 unsigned int mask;
3314 unsigned int result, pos, width;
3315 unsigned int z, s;
3316
3317 pos = lsb;
3318 width = (msb - lsb) + 1;
3319
3320 mask = ~ (-(1 << width));
3321 source &= mask;
3322 mask <<= pos;
3323 result = (* dest) & ~ mask;
3324 result |= source << pos;
3325
3326 /* Compute the condition codes. */
3327 z = (result == 0);
3328 s = result & 0x80000000;
3329
3330 /* Store the result and condition codes. */
3331 PSW &= ~(PSW_Z | PSW_S | PSW_OV );
3332 PSW |= (z ? PSW_Z : 0) | (s ? PSW_S : 0);
3333
3334 * dest = result;
3335 }
3336
3337 void
3338 v850_shr (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p)
3339 {
3340 unsigned int result, z, s, cy;
3341
3342 op0 &= 0x1f;
3343 result = op1 >> op0;
3344
3345 /* Compute the condition codes. */
3346 z = (result == 0);
3347 s = (result & 0x80000000);
3348 cy = (op1 & (1 << (op0 - 1)));
3349
3350 /* Store the result and condition codes. */
3351 PSW &= ~(PSW_Z | PSW_S | PSW_OV | PSW_CY);
3352 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
3353 | (cy ? PSW_CY : 0));
3354
3355 *op2p = result;
3356 }
3357
3358 void
3359 v850_satadd (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p)
3360 {
3361 unsigned int result, z, s, cy, ov, sat;
3362
3363 result = op0 + op1;
3364
3365 /* Compute the condition codes. */
3366 z = (result == 0);
3367 s = (result & 0x80000000);
3368 cy = (result < op0 || result < op1);
3369 ov = ((op0 & 0x80000000) == (op1 & 0x80000000)
3370 && (op0 & 0x80000000) != (result & 0x80000000));
3371 sat = ov;
3372
3373 /* Store the result and condition codes. */
3374 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
3375 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
3376 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
3377 | (sat ? PSW_SAT : 0));
3378
3379 /* Handle saturated results. */
3380 if (sat && s)
3381 {
3382 result = 0x7fffffff;
3383 PSW &= ~PSW_S;
3384 }
3385 else if (sat)
3386 {
3387 result = 0x80000000;
3388 PSW |= PSW_S;
3389 }
3390
3391 *op2p = result;
3392 }
3393
3394 void
3395 v850_satsub (SIM_DESC sd, unsigned int op0, unsigned int op1, unsigned int *op2p)
3396 {
3397 unsigned int result, z, s, cy, ov, sat;
3398
3399 /* Compute the result. */
3400 result = op1 - op0;
3401
3402 /* Compute the condition codes. */
3403 z = (result == 0);
3404 s = (result & 0x80000000);
3405 cy = (op1 < op0);
3406 ov = ((op1 & 0x80000000) != (op0 & 0x80000000)
3407 && (op1 & 0x80000000) != (result & 0x80000000));
3408 sat = ov;
3409
3410 /* Store the result and condition codes. */
3411 PSW &= ~(PSW_Z | PSW_S | PSW_CY | PSW_OV);
3412 PSW |= ((z ? PSW_Z : 0) | (s ? PSW_S : 0)
3413 | (cy ? PSW_CY : 0) | (ov ? PSW_OV : 0)
3414 | (sat ? PSW_SAT : 0));
3415
3416 /* Handle saturated results. */
3417 if (sat && s)
3418 {
3419 result = 0x7fffffff;
3420 PSW &= ~PSW_S;
3421 }
3422 else if (sat)
3423 {
3424 result = 0x80000000;
3425 PSW |= PSW_S;
3426 }
3427
3428 *op2p = result;
3429 }
3430
3431 unsigned32
3432 load_data_mem (SIM_DESC sd,
3433 SIM_ADDR addr,
3434 int len)
3435 {
3436 uint32 data;
3437
3438 switch (len)
3439 {
3440 case 1:
3441 data = sim_core_read_unaligned_1 (STATE_CPU (sd, 0),
3442 PC, read_map, addr);
3443 break;
3444 case 2:
3445 data = sim_core_read_unaligned_2 (STATE_CPU (sd, 0),
3446 PC, read_map, addr);
3447 break;
3448 case 4:
3449 data = sim_core_read_unaligned_4 (STATE_CPU (sd, 0),
3450 PC, read_map, addr);
3451 break;
3452 default:
3453 abort ();
3454 }
3455 return data;
3456 }
3457
3458 void
3459 store_data_mem (SIM_DESC sd,
3460 SIM_ADDR addr,
3461 int len,
3462 unsigned32 data)
3463 {
3464 switch (len)
3465 {
3466 case 1:
3467 store_mem (addr, 1, data);
3468 break;
3469 case 2:
3470 store_mem (addr, 2, data);
3471 break;
3472 case 4:
3473 store_mem (addr, 4, data);
3474 break;
3475 default:
3476 abort ();
3477 }
3478 }
3479
3480 int
3481 mpu_load_mem_test (SIM_DESC sd, unsigned int addr, int size, int base_reg)
3482 {
3483 int result = 1;
3484
3485 if (PSW & PSW_DMP)
3486 {
3487 if (IPE0 && addr >= IPA2ADDR (IPA0L) && addr <= IPA2ADDR (IPA0L) && IPR0)
3488 {
3489 /* text area */
3490 }
3491 else if (IPE1 && addr >= IPA2ADDR (IPA1L) && addr <= IPA2ADDR (IPA1L) && IPR1)
3492 {
3493 /* text area */
3494 }
3495 else if (IPE2 && addr >= IPA2ADDR (IPA2L) && addr <= IPA2ADDR (IPA2L) && IPR2)
3496 {
3497 /* text area */
3498 }
3499 else if (IPE3 && addr >= IPA2ADDR (IPA3L) && addr <= IPA2ADDR (IPA3L) && IPR3)
3500 {
3501 /* text area */
3502 }
3503 else if (addr >= PPA2ADDR (PPA & ~PPM) && addr <= DPA2ADDR (PPA | PPM))
3504 {
3505 /* preifarallel area */
3506 }
3507 else if (addr >= PPA2ADDR (SPAL) && addr <= DPA2ADDR (SPAU))
3508 {
3509 /* stack area */
3510 }
3511 else if (DPE0 && addr >= DPA2ADDR (DPA0L) && addr <= DPA2ADDR (DPA0L) && DPR0
3512 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3513 {
3514 /* data area */
3515 }
3516 else if (DPE1 && addr >= DPA2ADDR (DPA1L) && addr <= DPA2ADDR (DPA1L) && DPR1
3517 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3518 {
3519 /* data area */
3520 }
3521 else if (DPE2 && addr >= DPA2ADDR (DPA2L) && addr <= DPA2ADDR (DPA2L) && DPR2
3522 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3523 {
3524 /* data area */
3525 }
3526 else if (DPE3 && addr >= DPA2ADDR (DPA3L) && addr <= DPA2ADDR (DPA3L) && DPR3
3527 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3528 {
3529 /* data area */
3530 }
3531 else
3532 {
3533 VMECR &= ~(VMECR_VMW | VMECR_VMX);
3534 VMECR |= VMECR_VMR;
3535 VMADR = addr;
3536 VMTID = TID;
3537 FEIC = 0x431;
3538
3539 PC = 0x30;
3540
3541 SignalException (sd);
3542 result = 0;
3543 }
3544 }
3545
3546 return result;
3547 }
3548
3549 int
3550 mpu_store_mem_test (SIM_DESC sd, unsigned int addr, int size, int base_reg)
3551 {
3552 int result = 1;
3553
3554 if (PSW & PSW_DMP)
3555 {
3556 if (addr >= PPA2ADDR (PPA & ~PPM) && addr <= DPA2ADDR (PPA | PPM))
3557 {
3558 /* preifarallel area */
3559 }
3560 else if (addr >= PPA2ADDR (SPAL) && addr <= DPA2ADDR (SPAU))
3561 {
3562 /* stack area */
3563 }
3564 else if (DPE0 && addr >= DPA2ADDR (DPA0L) && addr <= DPA2ADDR (DPA0L) && DPW0
3565 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3566 {
3567 /* data area */
3568 }
3569 else if (DPE1 && addr >= DPA2ADDR (DPA1L) && addr <= DPA2ADDR (DPA1L) && DPW1
3570 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3571 {
3572 /* data area */
3573 }
3574 else if (DPE2 && addr >= DPA2ADDR (DPA2L) && addr <= DPA2ADDR (DPA2L) && DPW2
3575 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3576 {
3577 /* data area */
3578 }
3579 else if (DPE3 && addr >= DPA2ADDR (DPA3L) && addr <= DPA2ADDR (DPA3L) && DPW3
3580 && ((SPAL & SPAL_SPS) ? base_reg == SP_REGNO : 1))
3581 {
3582 /* data area */
3583 }
3584 else
3585 {
3586 if (addr >= PPA2ADDR (PPA & ~PPM) && addr <= DPA2ADDR (PPA | PPM))
3587 {
3588 FEIC = 0x432;
3589 VPTID = TID;
3590 VPADR = PC;
3591 #ifdef NOT_YET
3592 VIP_PP;
3593 VPECR;
3594 #endif
3595 }
3596 else
3597 {
3598 FEIC = 0x431;
3599 VMTID = TID;
3600 VMADR = VMECR;
3601 VMECR &= ~(VMECR_VMW | VMECR_VMX);
3602 VMECR |= VMECR_VMR;
3603 PC = 0x30;
3604 }
3605 result = 0;
3606 }
3607 }
3608
3609 return result;
3610 }
3611
The GNU Binutils are a collection of binary tools.