]> git.ipfire.org Git - thirdparty/binutils-gdb.git/blob - sim/mips/mdmx.c
Copyright updates for 2007.
[thirdparty/binutils-gdb.git] / sim / mips / mdmx.c
1 /* Simulation code for the MIPS MDMX ASE.
2 Copyright (C) 2002, 2007 Free Software Foundation, Inc.
3 Contributed by Ed Satterthwaite and Chris Demetriou, of Broadcom
4 Corporation (SiByte).
5
6 This file is part of GDB, the GNU debugger.
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2, or (at your option)
11 any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License along
19 with this program; if not, write to the Free Software Foundation, Inc.,
20 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
21
22 #include <stdio.h>
23
24 #include "sim-main.h"
25
26 /* Within mdmx.c we refer to the sim_cpu directly. */
27 #define CPU cpu
28 #define SD (CPU_STATE(CPU))
29
30 /* XXX FIXME: temporary hack while the impact of making unpredictable()
31 a "normal" (non-igen) function is evaluated. */
32 #undef Unpredictable
33 #define Unpredictable() unpredictable_action (cpu, cia)
34
35 /* MDMX Representations
36
37 An 8-bit packed byte element (OB) is always unsigned.
38 The 24-bit accumulators are signed and are represented as 32-bit
39 signed values, which are reduced to 24-bit signed values prior to
40 Round and Clamp operations.
41
42 A 16-bit packed halfword element (QH) is always signed.
43 The 48-bit accumulators are signed and are represented as 64-bit
44 signed values, which are reduced to 48-bit signed values prior to
45 Round and Clamp operations.
46
47 The code below assumes a 2's-complement representation of signed
48 quantities. Care is required to clear extended sign bits when
49 repacking fields.
50
51 The code (and the code for arithmetic shifts in mips.igen) also makes
52 the (not guaranteed portable) assumption that right shifts of signed
53 quantities in C do sign extension. */
54
55 typedef unsigned64 unsigned48;
56 #define MASK48 (UNSIGNED64 (0xffffffffffff))
57
58 typedef unsigned32 unsigned24;
59 #define MASK24 (UNSIGNED32 (0xffffff))
60
61 typedef enum {
62 mdmx_ob, /* OB (octal byte) */
63 mdmx_qh /* QH (quad half-word) */
64 } MX_fmt;
65
66 typedef enum {
67 sel_elem, /* element select */
68 sel_vect, /* vector select */
69 sel_imm /* immediate select */
70 } VT_select;
71
72 #define OB_MAX ((unsigned8)0xFF)
73 #define QH_MIN ((signed16)0x8000)
74 #define QH_MAX ((signed16)0x7FFF)
75
76 #define OB_CLAMP(x) ((unsigned8)((x) > OB_MAX ? OB_MAX : (x)))
77 #define QH_CLAMP(x) ((signed16)((x) < QH_MIN ? QH_MIN : \
78 ((x) > QH_MAX ? QH_MAX : (x))))
79
80 #define MX_FMT(fmtsel) (((fmtsel) & 0x1) == 0 ? mdmx_ob : mdmx_qh)
81 #define MX_VT(fmtsel) (((fmtsel) & 0x10) == 0 ? sel_elem : \
82 (((fmtsel) & 0x18) == 0x10 ? sel_vect : sel_imm))
83
84 #define QH_ELEM(v,fmtsel) \
85 ((signed16)(((v) >> (((fmtsel) & 0xC) << 2)) & 0xFFFF))
86 #define OB_ELEM(v,fmtsel) \
87 ((unsigned8)(((v) >> (((fmtsel) & 0xE) << 2)) & 0xFF))
88
89
90 typedef signed16 (*QH_FUNC)(signed16, signed16);
91 typedef unsigned8 (*OB_FUNC)(unsigned8, unsigned8);
92
93 /* vectorized logical operators */
94
95 static signed16
96 AndQH(signed16 ts, signed16 tt)
97 {
98 return (signed16)((unsigned16)ts & (unsigned16)tt);
99 }
100
101 static unsigned8
102 AndOB(unsigned8 ts, unsigned8 tt)
103 {
104 return ts & tt;
105 }
106
107 static signed16
108 NorQH(signed16 ts, signed16 tt)
109 {
110 return (signed16)(((unsigned16)ts | (unsigned16)tt) ^ 0xFFFF);
111 }
112
113 static unsigned8
114 NorOB(unsigned8 ts, unsigned8 tt)
115 {
116 return (ts | tt) ^ 0xFF;
117 }
118
119 static signed16
120 OrQH(signed16 ts, signed16 tt)
121 {
122 return (signed16)((unsigned16)ts | (unsigned16)tt);
123 }
124
125 static unsigned8
126 OrOB(unsigned8 ts, unsigned8 tt)
127 {
128 return ts | tt;
129 }
130
131 static signed16
132 XorQH(signed16 ts, signed16 tt)
133 {
134 return (signed16)((unsigned16)ts ^ (unsigned16)tt);
135 }
136
137 static unsigned8
138 XorOB(unsigned8 ts, unsigned8 tt)
139 {
140 return ts ^ tt;
141 }
142
143 static signed16
144 SLLQH(signed16 ts, signed16 tt)
145 {
146 unsigned32 s = (unsigned32)tt & 0xF;
147 return (signed16)(((unsigned32)ts << s) & 0xFFFF);
148 }
149
150 static unsigned8
151 SLLOB(unsigned8 ts, unsigned8 tt)
152 {
153 unsigned32 s = tt & 0x7;
154 return (ts << s) & 0xFF;
155 }
156
157 static signed16
158 SRLQH(signed16 ts, signed16 tt)
159 {
160 unsigned32 s = (unsigned32)tt & 0xF;
161 return (signed16)((unsigned16)ts >> s);
162 }
163
164 static unsigned8
165 SRLOB(unsigned8 ts, unsigned8 tt)
166 {
167 unsigned32 s = tt & 0x7;
168 return ts >> s;
169 }
170
171
172 /* Vectorized arithmetic operators. */
173
174 static signed16
175 AddQH(signed16 ts, signed16 tt)
176 {
177 signed32 t = (signed32)ts + (signed32)tt;
178 return QH_CLAMP(t);
179 }
180
181 static unsigned8
182 AddOB(unsigned8 ts, unsigned8 tt)
183 {
184 unsigned32 t = (unsigned32)ts + (unsigned32)tt;
185 return OB_CLAMP(t);
186 }
187
188 static signed16
189 SubQH(signed16 ts, signed16 tt)
190 {
191 signed32 t = (signed32)ts - (signed32)tt;
192 return QH_CLAMP(t);
193 }
194
195 static unsigned8
196 SubOB(unsigned8 ts, unsigned8 tt)
197 {
198 signed32 t;
199 t = (signed32)ts - (signed32)tt;
200 if (t < 0)
201 t = 0;
202 return (unsigned8)t;
203 }
204
205 static signed16
206 MinQH(signed16 ts, signed16 tt)
207 {
208 return (ts < tt ? ts : tt);
209 }
210
211 static unsigned8
212 MinOB(unsigned8 ts, unsigned8 tt)
213 {
214 return (ts < tt ? ts : tt);
215 }
216
217 static signed16
218 MaxQH(signed16 ts, signed16 tt)
219 {
220 return (ts > tt ? ts : tt);
221 }
222
223 static unsigned8
224 MaxOB(unsigned8 ts, unsigned8 tt)
225 {
226 return (ts > tt ? ts : tt);
227 }
228
229 static signed16
230 MulQH(signed16 ts, signed16 tt)
231 {
232 signed32 t = (signed32)ts * (signed32)tt;
233 return QH_CLAMP(t);
234 }
235
236 static unsigned8
237 MulOB(unsigned8 ts, unsigned8 tt)
238 {
239 unsigned32 t = (unsigned32)ts * (unsigned32)tt;
240 return OB_CLAMP(t);
241 }
242
243 /* "msgn" and "sra" are defined only for QH format. */
244
245 static signed16
246 MsgnQH(signed16 ts, signed16 tt)
247 {
248 signed16 t;
249 if (ts < 0)
250 t = (tt == QH_MIN ? QH_MAX : -tt);
251 else if (ts == 0)
252 t = 0;
253 else
254 t = tt;
255 return t;
256 }
257
258 static signed16
259 SRAQH(signed16 ts, signed16 tt)
260 {
261 unsigned32 s = (unsigned32)tt & 0xF;
262 return (signed16)((signed32)ts >> s);
263 }
264
265
266 /* "pabsdiff" and "pavg" are defined only for OB format. */
267
268 static unsigned8
269 AbsDiffOB(unsigned8 ts, unsigned8 tt)
270 {
271 return (ts >= tt ? ts - tt : tt - ts);
272 }
273
274 static unsigned8
275 AvgOB(unsigned8 ts, unsigned8 tt)
276 {
277 return ((unsigned32)ts + (unsigned32)tt + 1) >> 1;
278 }
279
280
281 /* Dispatch tables for operations that update a CPR. */
282
283 static const QH_FUNC qh_func[] = {
284 AndQH, NorQH, OrQH, XorQH, SLLQH, SRLQH,
285 AddQH, SubQH, MinQH, MaxQH,
286 MulQH, MsgnQH, SRAQH, NULL, NULL
287 };
288
289 static const OB_FUNC ob_func[] = {
290 AndOB, NorOB, OrOB, XorOB, SLLOB, SRLOB,
291 AddOB, SubOB, MinOB, MaxOB,
292 MulOB, NULL, NULL, AbsDiffOB, AvgOB
293 };
294
295 /* Auxiliary functions for CPR updates. */
296
297 /* Vector mapping for QH format. */
298 static unsigned64
299 qh_vector_op(unsigned64 v1, unsigned64 v2, QH_FUNC func)
300 {
301 unsigned64 result = 0;
302 int i;
303 signed16 h, h1, h2;
304
305 for (i = 0; i < 64; i += 16)
306 {
307 h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
308 h2 = (signed16)(v2 & 0xFFFF); v2 >>= 16;
309 h = (*func)(h1, h2);
310 result |= ((unsigned64)((unsigned16)h) << i);
311 }
312 return result;
313 }
314
315 static unsigned64
316 qh_map_op(unsigned64 v1, signed16 h2, QH_FUNC func)
317 {
318 unsigned64 result = 0;
319 int i;
320 signed16 h, h1;
321
322 for (i = 0; i < 64; i += 16)
323 {
324 h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
325 h = (*func)(h1, h2);
326 result |= ((unsigned64)((unsigned16)h) << i);
327 }
328 return result;
329 }
330
331
332 /* Vector operations for OB format. */
333
334 static unsigned64
335 ob_vector_op(unsigned64 v1, unsigned64 v2, OB_FUNC func)
336 {
337 unsigned64 result = 0;
338 int i;
339 unsigned8 b, b1, b2;
340
341 for (i = 0; i < 64; i += 8)
342 {
343 b1 = v1 & 0xFF; v1 >>= 8;
344 b2 = v2 & 0xFF; v2 >>= 8;
345 b = (*func)(b1, b2);
346 result |= ((unsigned64)b << i);
347 }
348 return result;
349 }
350
351 static unsigned64
352 ob_map_op(unsigned64 v1, unsigned8 b2, OB_FUNC func)
353 {
354 unsigned64 result = 0;
355 int i;
356 unsigned8 b, b1;
357
358 for (i = 0; i < 64; i += 8)
359 {
360 b1 = v1 & 0xFF; v1 >>= 8;
361 b = (*func)(b1, b2);
362 result |= ((unsigned64)b << i);
363 }
364 return result;
365 }
366
367
368 /* Primary entry for operations that update CPRs. */
369 unsigned64
370 mdmx_cpr_op(sim_cpu *cpu,
371 address_word cia,
372 int op,
373 unsigned64 op1,
374 int vt,
375 MX_fmtsel fmtsel)
376 {
377 unsigned64 op2;
378 unsigned64 result = 0;
379
380 switch (MX_FMT (fmtsel))
381 {
382 case mdmx_qh:
383 switch (MX_VT (fmtsel))
384 {
385 case sel_elem:
386 op2 = ValueFPR(vt, fmt_mdmx);
387 result = qh_map_op(op1, QH_ELEM(op2, fmtsel), qh_func[op]);
388 break;
389 case sel_vect:
390 result = qh_vector_op(op1, ValueFPR(vt, fmt_mdmx), qh_func[op]);
391 break;
392 case sel_imm:
393 result = qh_map_op(op1, vt, qh_func[op]);
394 break;
395 }
396 break;
397 case mdmx_ob:
398 switch (MX_VT (fmtsel))
399 {
400 case sel_elem:
401 op2 = ValueFPR(vt, fmt_mdmx);
402 result = ob_map_op(op1, OB_ELEM(op2, fmtsel), ob_func[op]);
403 break;
404 case sel_vect:
405 result = ob_vector_op(op1, ValueFPR(vt, fmt_mdmx), ob_func[op]);
406 break;
407 case sel_imm:
408 result = ob_map_op(op1, vt, ob_func[op]);
409 break;
410 }
411 break;
412 default:
413 Unpredictable ();
414 }
415
416 return result;
417 }
418
419
420 /* Operations that update CCs */
421
422 static void
423 qh_vector_test(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int cond)
424 {
425 int i;
426 signed16 h1, h2;
427 int boolean;
428
429 for (i = 0; i < 4; i++)
430 {
431 h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
432 h2 = (signed16)(v2 & 0xFFFF); v2 >>= 16;
433 boolean = ((cond & MX_C_EQ) && (h1 == h2)) ||
434 ((cond & MX_C_LT) && (h1 < h2));
435 SETFCC(i, boolean);
436 }
437 }
438
439 static void
440 qh_map_test(sim_cpu *cpu, unsigned64 v1, signed16 h2, int cond)
441 {
442 int i;
443 signed16 h1;
444 int boolean;
445
446 for (i = 0; i < 4; i++)
447 {
448 h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
449 boolean = ((cond & MX_C_EQ) && (h1 == h2)) ||
450 ((cond & MX_C_LT) && (h1 < h2));
451 SETFCC(i, boolean);
452 }
453 }
454
455 static void
456 ob_vector_test(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int cond)
457 {
458 int i;
459 unsigned8 b1, b2;
460 int boolean;
461
462 for (i = 0; i < 8; i++)
463 {
464 b1 = v1 & 0xFF; v1 >>= 8;
465 b2 = v2 & 0xFF; v2 >>= 8;
466 boolean = ((cond & MX_C_EQ) && (b1 == b2)) ||
467 ((cond & MX_C_LT) && (b1 < b2));
468 SETFCC(i, boolean);
469 }
470 }
471
472 static void
473 ob_map_test(sim_cpu *cpu, unsigned64 v1, unsigned8 b2, int cond)
474 {
475 int i;
476 unsigned8 b1;
477 int boolean;
478
479 for (i = 0; i < 8; i++)
480 {
481 b1 = (unsigned8)(v1 & 0xFF); v1 >>= 8;
482 boolean = ((cond & MX_C_EQ) && (b1 == b2)) ||
483 ((cond & MX_C_LT) && (b1 < b2));
484 SETFCC(i, boolean);
485 }
486 }
487
488
489 void
490 mdmx_cc_op(sim_cpu *cpu,
491 address_word cia,
492 int cond,
493 unsigned64 v1,
494 int vt,
495 MX_fmtsel fmtsel)
496 {
497 unsigned64 op2;
498
499 switch (MX_FMT (fmtsel))
500 {
501 case mdmx_qh:
502 switch (MX_VT (fmtsel))
503 {
504 case sel_elem:
505 op2 = ValueFPR(vt, fmt_mdmx);
506 qh_map_test(cpu, v1, QH_ELEM(op2, fmtsel), cond);
507 break;
508 case sel_vect:
509 qh_vector_test(cpu, v1, ValueFPR(vt, fmt_mdmx), cond);
510 break;
511 case sel_imm:
512 qh_map_test(cpu, v1, vt, cond);
513 break;
514 }
515 break;
516 case mdmx_ob:
517 switch (MX_VT (fmtsel))
518 {
519 case sel_elem:
520 op2 = ValueFPR(vt, fmt_mdmx);
521 ob_map_test(cpu, v1, OB_ELEM(op2, fmtsel), cond);
522 break;
523 case sel_vect:
524 ob_vector_test(cpu, v1, ValueFPR(vt, fmt_mdmx), cond);
525 break;
526 case sel_imm:
527 ob_map_test(cpu, v1, vt, cond);
528 break;
529 }
530 break;
531 default:
532 Unpredictable ();
533 }
534 }
535
536
537 /* Pick operations. */
538
539 static unsigned64
540 qh_vector_pick(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int tf)
541 {
542 unsigned64 result = 0;
543 int i, s;
544 unsigned16 h;
545
546 s = 0;
547 for (i = 0; i < 4; i++)
548 {
549 h = ((GETFCC(i) == tf) ? (v1 & 0xFFFF) : (v2 & 0xFFFF));
550 v1 >>= 16; v2 >>= 16;
551 result |= ((unsigned64)h << s);
552 s += 16;
553 }
554 return result;
555 }
556
557 static unsigned64
558 qh_map_pick(sim_cpu *cpu, unsigned64 v1, signed16 h2, int tf)
559 {
560 unsigned64 result = 0;
561 int i, s;
562 unsigned16 h;
563
564 s = 0;
565 for (i = 0; i < 4; i++)
566 {
567 h = (GETFCC(i) == tf) ? (v1 & 0xFFFF) : (unsigned16)h2;
568 v1 >>= 16;
569 result |= ((unsigned64)h << s);
570 s += 16;
571 }
572 return result;
573 }
574
575 static unsigned64
576 ob_vector_pick(sim_cpu *cpu, unsigned64 v1, unsigned64 v2, int tf)
577 {
578 unsigned64 result = 0;
579 int i, s;
580 unsigned8 b;
581
582 s = 0;
583 for (i = 0; i < 8; i++)
584 {
585 b = (GETFCC(i) == tf) ? (v1 & 0xFF) : (v2 & 0xFF);
586 v1 >>= 8; v2 >>= 8;
587 result |= ((unsigned64)b << s);
588 s += 8;
589 }
590 return result;
591 }
592
593 static unsigned64
594 ob_map_pick(sim_cpu *cpu, unsigned64 v1, unsigned8 b2, int tf)
595 {
596 unsigned64 result = 0;
597 int i, s;
598 unsigned8 b;
599
600 s = 0;
601 for (i = 0; i < 8; i++)
602 {
603 b = (GETFCC(i) == tf) ? (v1 & 0xFF) : b2;
604 v1 >>= 8;
605 result |= ((unsigned64)b << s);
606 s += 8;
607 }
608 return result;
609 }
610
611
612 unsigned64
613 mdmx_pick_op(sim_cpu *cpu,
614 address_word cia,
615 int tf,
616 unsigned64 v1,
617 int vt,
618 MX_fmtsel fmtsel)
619 {
620 unsigned64 result = 0;
621 unsigned64 op2;
622
623 switch (MX_FMT (fmtsel))
624 {
625 case mdmx_qh:
626 switch (MX_VT (fmtsel))
627 {
628 case sel_elem:
629 op2 = ValueFPR(vt, fmt_mdmx);
630 result = qh_map_pick(cpu, v1, QH_ELEM(op2, fmtsel), tf);
631 break;
632 case sel_vect:
633 result = qh_vector_pick(cpu, v1, ValueFPR(vt, fmt_mdmx), tf);
634 break;
635 case sel_imm:
636 result = qh_map_pick(cpu, v1, vt, tf);
637 break;
638 }
639 break;
640 case mdmx_ob:
641 switch (MX_VT (fmtsel))
642 {
643 case sel_elem:
644 op2 = ValueFPR(vt, fmt_mdmx);
645 result = ob_map_pick(cpu, v1, OB_ELEM(op2, fmtsel), tf);
646 break;
647 case sel_vect:
648 result = ob_vector_pick(cpu, v1, ValueFPR(vt, fmt_mdmx), tf);
649 break;
650 case sel_imm:
651 result = ob_map_pick(cpu, v1, vt, tf);
652 break;
653 }
654 break;
655 default:
656 Unpredictable ();
657 }
658 return result;
659 }
660
661
662 /* Accumulators. */
663
664 typedef void (*QH_ACC)(signed48 *a, signed16 ts, signed16 tt);
665
666 static void
667 AccAddAQH(signed48 *a, signed16 ts, signed16 tt)
668 {
669 *a += (signed48)ts + (signed48)tt;
670 }
671
672 static void
673 AccAddLQH(signed48 *a, signed16 ts, signed16 tt)
674 {
675 *a = (signed48)ts + (signed48)tt;
676 }
677
678 static void
679 AccMulAQH(signed48 *a, signed16 ts, signed16 tt)
680 {
681 *a += (signed48)ts * (signed48)tt;
682 }
683
684 static void
685 AccMulLQH(signed48 *a, signed16 ts, signed16 tt)
686 {
687 *a = (signed48)ts * (signed48)tt;
688 }
689
690 static void
691 SubMulAQH(signed48 *a, signed16 ts, signed16 tt)
692 {
693 *a -= (signed48)ts * (signed48)tt;
694 }
695
696 static void
697 SubMulLQH(signed48 *a, signed16 ts, signed16 tt)
698 {
699 *a = -((signed48)ts * (signed48)tt);
700 }
701
702 static void
703 AccSubAQH(signed48 *a, signed16 ts, signed16 tt)
704 {
705 *a += (signed48)ts - (signed48)tt;
706 }
707
708 static void
709 AccSubLQH(signed48 *a, signed16 ts, signed16 tt)
710 {
711 *a = (signed48)ts - (signed48)tt;
712 }
713
714
715 typedef void (*OB_ACC)(signed24 *acc, unsigned8 ts, unsigned8 tt);
716
717 static void
718 AccAddAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
719 {
720 *a += (signed24)ts + (signed24)tt;
721 }
722
723 static void
724 AccAddLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
725 {
726 *a = (signed24)ts + (signed24)tt;
727 }
728
729 static void
730 AccMulAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
731 {
732 *a += (signed24)ts * (signed24)tt;
733 }
734
735 static void
736 AccMulLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
737 {
738 *a = (signed24)ts * (signed24)tt;
739 }
740
741 static void
742 SubMulAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
743 {
744 *a -= (signed24)ts * (signed24)tt;
745 }
746
747 static void
748 SubMulLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
749 {
750 *a = -((signed24)ts * (signed24)tt);
751 }
752
753 static void
754 AccSubAOB(signed24 *a, unsigned8 ts, unsigned8 tt)
755 {
756 *a += (signed24)ts - (signed24)tt;
757 }
758
759 static void
760 AccSubLOB(signed24 *a, unsigned8 ts, unsigned8 tt)
761 {
762 *a = (signed24)ts - (signed24)tt;
763 }
764
765 static void
766 AccAbsDiffOB(signed24 *a, unsigned8 ts, unsigned8 tt)
767 {
768 unsigned8 t = (ts >= tt ? ts - tt : tt - ts);
769 *a += (signed24)t;
770 }
771
772
773 /* Dispatch tables for operations that update a CPR. */
774
775 static const QH_ACC qh_acc[] = {
776 AccAddAQH, AccAddAQH, AccMulAQH, AccMulLQH,
777 SubMulAQH, SubMulLQH, AccSubAQH, AccSubLQH,
778 NULL
779 };
780
781 static const OB_ACC ob_acc[] = {
782 AccAddAOB, AccAddLOB, AccMulAOB, AccMulLOB,
783 SubMulAOB, SubMulLOB, AccSubAOB, AccSubLOB,
784 AccAbsDiffOB
785 };
786
787
788 static void
789 qh_vector_acc(signed48 a[], unsigned64 v1, unsigned64 v2, QH_ACC acc)
790 {
791 int i;
792 signed16 h1, h2;
793
794 for (i = 0; i < 4; i++)
795 {
796 h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
797 h2 = (signed16)(v2 & 0xFFFF); v2 >>= 16;
798 (*acc)(&a[i], h1, h2);
799 }
800 }
801
802 static void
803 qh_map_acc(signed48 a[], unsigned64 v1, signed16 h2, QH_ACC acc)
804 {
805 int i;
806 signed16 h1;
807
808 for (i = 0; i < 4; i++)
809 {
810 h1 = (signed16)(v1 & 0xFFFF); v1 >>= 16;
811 (*acc)(&a[i], h1, h2);
812 }
813 }
814
815 static void
816 ob_vector_acc(signed24 a[], unsigned64 v1, unsigned64 v2, OB_ACC acc)
817 {
818 int i;
819 unsigned8 b1, b2;
820
821 for (i = 0; i < 8; i++)
822 {
823 b1 = v1 & 0xFF; v1 >>= 8;
824 b2 = v2 & 0xFF; v2 >>= 8;
825 (*acc)(&a[i], b1, b2);
826 }
827 }
828
829 static void
830 ob_map_acc(signed24 a[], unsigned64 v1, unsigned8 b2, OB_ACC acc)
831 {
832 int i;
833 unsigned8 b1;
834
835 for (i = 0; i < 8; i++)
836 {
837 b1 = v1 & 0xFF; v1 >>= 8;
838 (*acc)(&a[i], b1, b2);
839 }
840 }
841
842
843 /* Primary entry for operations that accumulate */
844 void
845 mdmx_acc_op(sim_cpu *cpu,
846 address_word cia,
847 int op,
848 unsigned64 op1,
849 int vt,
850 MX_fmtsel fmtsel)
851 {
852 unsigned64 op2;
853
854 switch (MX_FMT (fmtsel))
855 {
856 case mdmx_qh:
857 switch (MX_VT (fmtsel))
858 {
859 case sel_elem:
860 op2 = ValueFPR(vt, fmt_mdmx);
861 qh_map_acc(ACC.qh, op1, QH_ELEM(op2, fmtsel), qh_acc[op]);
862 break;
863 case sel_vect:
864 qh_vector_acc(ACC.qh, op1, ValueFPR(vt, fmt_mdmx), qh_acc[op]);
865 break;
866 case sel_imm:
867 qh_map_acc(ACC.qh, op1, vt, qh_acc[op]);
868 break;
869 }
870 break;
871 case mdmx_ob:
872 switch (MX_VT (fmtsel))
873 {
874 case sel_elem:
875 op2 = ValueFPR(vt, fmt_mdmx);
876 ob_map_acc(ACC.ob, op1, OB_ELEM(op2, fmtsel), ob_acc[op]);
877 break;
878 case sel_vect:
879 ob_vector_acc(ACC.ob, op1, ValueFPR(vt, fmt_mdmx), ob_acc[op]);
880 break;
881 case sel_imm:
882 ob_map_acc(ACC.ob, op1, vt, ob_acc[op]);
883 break;
884 }
885 break;
886 default:
887 Unpredictable ();
888 }
889 }
890
891
892 /* Reading and writing accumulator (no conversion). */
893
894 unsigned64
895 mdmx_rac_op(sim_cpu *cpu,
896 address_word cia,
897 int op,
898 int fmt)
899 {
900 unsigned64 result;
901 unsigned int shift;
902 int i;
903
904 shift = op; /* L = 00, M = 01, H = 10. */
905 result = 0;
906
907 switch (fmt)
908 {
909 case MX_FMT_QH:
910 shift <<= 4; /* 16 bits per element. */
911 for (i = 3; i >= 0; --i)
912 {
913 result <<= 16;
914 result |= ((ACC.qh[i] >> shift) & 0xFFFF);
915 }
916 break;
917 case MX_FMT_OB:
918 shift <<= 3; /* 8 bits per element. */
919 for (i = 7; i >= 0; --i)
920 {
921 result <<= 8;
922 result |= ((ACC.ob[i] >> shift) & 0xFF);
923 }
924 break;
925 default:
926 Unpredictable ();
927 }
928 return result;
929 }
930
931 void
932 mdmx_wacl(sim_cpu *cpu,
933 address_word cia,
934 int fmt,
935 unsigned64 vs,
936 unsigned64 vt)
937 {
938 int i;
939
940 switch (fmt)
941 {
942 case MX_FMT_QH:
943 for (i = 0; i < 4; i++)
944 {
945 signed32 s = (signed16)(vs & 0xFFFF);
946 ACC.qh[i] = ((signed48)s << 16) | (vt & 0xFFFF);
947 vs >>= 16; vt >>= 16;
948 }
949 break;
950 case MX_FMT_OB:
951 for (i = 0; i < 8; i++)
952 {
953 signed16 s = (signed8)(vs & 0xFF);
954 ACC.ob[i] = ((signed24)s << 8) | (vt & 0xFF);
955 vs >>= 8; vt >>= 8;
956 }
957 break;
958 default:
959 Unpredictable ();
960 }
961 }
962
963 void
964 mdmx_wach(sim_cpu *cpu,
965 address_word cia,
966 int fmt,
967 unsigned64 vs)
968 {
969 int i;
970
971 switch (fmt)
972 {
973 case MX_FMT_QH:
974 for (i = 0; i < 4; i++)
975 {
976 signed32 s = (signed16)(vs & 0xFFFF);
977 ACC.qh[i] &= ~((signed48)0xFFFF << 32);
978 ACC.qh[i] |= ((signed48)s << 32);
979 vs >>= 16;
980 }
981 break;
982 case MX_FMT_OB:
983 for (i = 0; i < 8; i++)
984 {
985 ACC.ob[i] &= ~((signed24)0xFF << 16);
986 ACC.ob[i] |= ((signed24)(vs & 0xFF) << 16);
987 vs >>= 8;
988 }
989 break;
990 default:
991 Unpredictable ();
992 }
993 }
994
995
996 /* Reading and writing accumulator (rounding conversions).
997 Enumerating function guarantees s >= 0 for QH ops. */
998
999 typedef signed16 (*QH_ROUND)(signed48 a, signed16 s);
1000
1001 #define QH_BIT(n) ((unsigned48)1 << (n))
1002 #define QH_ONES(n) (((unsigned48)1 << (n))-1)
1003
1004 static signed16
1005 RNASQH(signed48 a, signed16 s)
1006 {
1007 signed48 t;
1008 signed16 result = 0;
1009
1010 if (s > 48)
1011 result = 0;
1012 else
1013 {
1014 t = (a >> s);
1015 if ((a & QH_BIT(47)) == 0)
1016 {
1017 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1018 t++;
1019 if (t > QH_MAX)
1020 t = QH_MAX;
1021 }
1022 else
1023 {
1024 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1025 {
1026 if (s > 1 && ((unsigned48)a & QH_ONES(s-1)) != 0)
1027 t++;
1028 }
1029 if (t < QH_MIN)
1030 t = QH_MIN;
1031 }
1032 result = (signed16)t;
1033 }
1034 return result;
1035 }
1036
1037 static signed16
1038 RNAUQH(signed48 a, signed16 s)
1039 {
1040 unsigned48 t;
1041 signed16 result;
1042
1043 if (s > 48)
1044 result = 0;
1045 else if (s == 48)
1046 result = ((unsigned48)a & MASK48) >> 47;
1047 else
1048 {
1049 t = ((unsigned48)a & MASK48) >> s;
1050 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1051 t++;
1052 if (t > 0xFFFF)
1053 t = 0xFFFF;
1054 result = (signed16)t;
1055 }
1056 return result;
1057 }
1058
1059 static signed16
1060 RNESQH(signed48 a, signed16 s)
1061 {
1062 signed48 t;
1063 signed16 result = 0;
1064
1065 if (s > 47)
1066 result = 0;
1067 else
1068 {
1069 t = (a >> s);
1070 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1071 {
1072 if (s == 1 || (a & QH_ONES(s-1)) == 0)
1073 t += t & 1;
1074 else
1075 t += 1;
1076 }
1077 if ((a & QH_BIT(47)) == 0)
1078 {
1079 if (t > QH_MAX)
1080 t = QH_MAX;
1081 }
1082 else
1083 {
1084 if (t < QH_MIN)
1085 t = QH_MIN;
1086 }
1087 result = (signed16)t;
1088 }
1089 return result;
1090 }
1091
1092 static signed16
1093 RNEUQH(signed48 a, signed16 s)
1094 {
1095 unsigned48 t;
1096 signed16 result;
1097
1098 if (s > 48)
1099 result = 0;
1100 else if (s == 48)
1101 result = ((unsigned48)a > QH_BIT(47) ? 1 : 0);
1102 else
1103 {
1104 t = ((unsigned48)a & MASK48) >> s;
1105 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1106 {
1107 if (s > 1 && (a & QH_ONES(s-1)) != 0)
1108 t++;
1109 else
1110 t += t & 1;
1111 }
1112 if (t > 0xFFFF)
1113 t = 0xFFFF;
1114 result = (signed16)t;
1115 }
1116 return result;
1117 }
1118
1119 static signed16
1120 RZSQH(signed48 a, signed16 s)
1121 {
1122 signed48 t;
1123 signed16 result = 0;
1124
1125 if (s > 47)
1126 result = 0;
1127 else
1128 {
1129 t = (a >> s);
1130 if ((a & QH_BIT(47)) == 0)
1131 {
1132 if (t > QH_MAX)
1133 t = QH_MAX;
1134 }
1135 else
1136 {
1137 if (t < QH_MIN)
1138 t = QH_MIN;
1139 }
1140 result = (signed16)t;
1141 }
1142 return result;
1143 }
1144
1145 static signed16
1146 RZUQH(signed48 a, signed16 s)
1147 {
1148 unsigned48 t;
1149 signed16 result = 0;
1150
1151 if (s > 48)
1152 result = 0;
1153 else if (s == 48)
1154 result = ((unsigned48)a > QH_BIT(47) ? 1 : 0);
1155 else
1156 {
1157 t = ((unsigned48)a & MASK48) >> s;
1158 if (t > 0xFFFF)
1159 t = 0xFFFF;
1160 result = (signed16)t;
1161 }
1162 return result;
1163 }
1164
1165
1166 typedef unsigned8 (*OB_ROUND)(signed24 a, unsigned8 s);
1167
1168 #define OB_BIT(n) ((unsigned24)1 << (n))
1169 #define OB_ONES(n) (((unsigned24)1 << (n))-1)
1170
1171 static unsigned8
1172 RNAUOB(signed24 a, unsigned8 s)
1173 {
1174 unsigned8 result;
1175 unsigned24 t;
1176
1177 if (s > 24)
1178 result = 0;
1179 else if (s == 24)
1180 result = ((unsigned24)a & MASK24) >> 23;
1181 else
1182 {
1183 t = ((unsigned24)a & MASK24) >> s;
1184 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1185 t ++;
1186 result = OB_CLAMP(t);
1187 }
1188 return result;
1189 }
1190
1191 static unsigned8
1192 RNEUOB(signed24 a, unsigned8 s)
1193 {
1194 unsigned8 result;
1195 unsigned24 t;
1196
1197 if (s > 24)
1198 result = 0;
1199 else if (s == 24)
1200 result = (((unsigned24)a & MASK24) > OB_BIT(23) ? 1 : 0);
1201 else
1202 {
1203 t = ((unsigned24)a & MASK24) >> s;
1204 if (s > 0 && ((a >> (s-1)) & 1) == 1)
1205 {
1206 if (s > 1 && (a & OB_ONES(s-1)) != 0)
1207 t++;
1208 else
1209 t += t & 1;
1210 }
1211 result = OB_CLAMP(t);
1212 }
1213 return result;
1214 }
1215
1216 static unsigned8
1217 RZUOB(signed24 a, unsigned8 s)
1218 {
1219 unsigned8 result;
1220 unsigned24 t;
1221
1222 if (s >= 24)
1223 result = 0;
1224 else
1225 {
1226 t = ((unsigned24)a & MASK24) >> s;
1227 result = OB_CLAMP(t);
1228 }
1229 return result;
1230 }
1231
1232
1233 static const QH_ROUND qh_round[] = {
1234 RNASQH, RNAUQH, RNESQH, RNEUQH, RZSQH, RZUQH
1235 };
1236
1237 static const OB_ROUND ob_round[] = {
1238 NULL, RNAUOB, NULL, RNEUOB, NULL, RZUOB
1239 };
1240
1241
1242 static unsigned64
1243 qh_vector_round(sim_cpu *cpu, address_word cia, unsigned64 v2, QH_ROUND round)
1244 {
1245 unsigned64 result = 0;
1246 int i, s;
1247 signed16 h, h2;
1248
1249 s = 0;
1250 for (i = 0; i < 4; i++)
1251 {
1252 h2 = (signed16)(v2 & 0xFFFF);
1253 if (h2 >= 0)
1254 h = (*round)(ACC.qh[i], h2);
1255 else
1256 {
1257 UnpredictableResult ();
1258 h = 0xdead;
1259 }
1260 v2 >>= 16;
1261 result |= ((unsigned64)((unsigned16)h) << s);
1262 s += 16;
1263 }
1264 return result;
1265 }
1266
1267 static unsigned64
1268 qh_map_round(sim_cpu *cpu, address_word cia, signed16 h2, QH_ROUND round)
1269 {
1270 unsigned64 result = 0;
1271 int i, s;
1272 signed16 h;
1273
1274 s = 0;
1275 for (i = 0; i < 4; i++)
1276 {
1277 if (h2 >= 0)
1278 h = (*round)(ACC.qh[i], h2);
1279 else
1280 {
1281 UnpredictableResult ();
1282 h = 0xdead;
1283 }
1284 result |= ((unsigned64)((unsigned16)h) << s);
1285 s += 16;
1286 }
1287 return result;
1288 }
1289
1290 static unsigned64
1291 ob_vector_round(sim_cpu *cpu, address_word cia, unsigned64 v2, OB_ROUND round)
1292 {
1293 unsigned64 result = 0;
1294 int i, s;
1295 unsigned8 b, b2;
1296
1297 s = 0;
1298 for (i = 0; i < 8; i++)
1299 {
1300 b2 = v2 & 0xFF; v2 >>= 8;
1301 b = (*round)(ACC.ob[i], b2);
1302 result |= ((unsigned64)b << s);
1303 s += 8;
1304 }
1305 return result;
1306 }
1307
1308 static unsigned64
1309 ob_map_round(sim_cpu *cpu, address_word cia, unsigned8 b2, OB_ROUND round)
1310 {
1311 unsigned64 result = 0;
1312 int i, s;
1313 unsigned8 b;
1314
1315 s = 0;
1316 for (i = 0; i < 8; i++)
1317 {
1318 b = (*round)(ACC.ob[i], b2);
1319 result |= ((unsigned64)b << s);
1320 s += 8;
1321 }
1322 return result;
1323 }
1324
1325
1326 unsigned64
1327 mdmx_round_op(sim_cpu *cpu,
1328 address_word cia,
1329 int rm,
1330 int vt,
1331 MX_fmtsel fmtsel)
1332 {
1333 unsigned64 op2;
1334 unsigned64 result = 0;
1335
1336 switch (MX_FMT (fmtsel))
1337 {
1338 case mdmx_qh:
1339 switch (MX_VT (fmtsel))
1340 {
1341 case sel_elem:
1342 op2 = ValueFPR(vt, fmt_mdmx);
1343 result = qh_map_round(cpu, cia, QH_ELEM(op2, fmtsel), qh_round[rm]);
1344 break;
1345 case sel_vect:
1346 op2 = ValueFPR(vt, fmt_mdmx);
1347 result = qh_vector_round(cpu, cia, op2, qh_round[rm]);
1348 break;
1349 case sel_imm:
1350 result = qh_map_round(cpu, cia, vt, qh_round[rm]);
1351 break;
1352 }
1353 break;
1354 case mdmx_ob:
1355 switch (MX_VT (fmtsel))
1356 {
1357 case sel_elem:
1358 op2 = ValueFPR(vt, fmt_mdmx);
1359 result = ob_map_round(cpu, cia, OB_ELEM(op2, fmtsel), ob_round[rm]);
1360 break;
1361 case sel_vect:
1362 op2 = ValueFPR(vt, fmt_mdmx);
1363 result = ob_vector_round(cpu, cia, op2, ob_round[rm]);
1364 break;
1365 case sel_imm:
1366 result = ob_map_round(cpu, cia, vt, ob_round[rm]);
1367 break;
1368 }
1369 break;
1370 default:
1371 Unpredictable ();
1372 }
1373
1374 return result;
1375 }
1376
1377
1378 /* Shuffle operation. */
1379
1380 typedef struct {
1381 enum {vs, ss, vt} source;
1382 unsigned int index;
1383 } sh_map;
1384
1385 static const sh_map ob_shuffle[][8] = {
1386 /* MDMX 2.0 encodings (3-4, 6-7). */
1387 /* vr5400 encoding (5), otherwise. */
1388 { }, /* RSVD */
1389 {{vt,4}, {vs,4}, {vt,5}, {vs,5}, {vt,6}, {vs,6}, {vt,7}, {vs,7}}, /* RSVD */
1390 {{vt,0}, {vs,0}, {vt,1}, {vs,1}, {vt,2}, {vs,2}, {vt,3}, {vs,3}}, /* RSVD */
1391 {{vs,0}, {ss,0}, {vs,1}, {ss,1}, {vs,2}, {ss,2}, {vs,3}, {ss,3}}, /* upsl */
1392 {{vt,1}, {vt,3}, {vt,5}, {vt,7}, {vs,1}, {vs,3}, {vs,5}, {vs,7}}, /* pach */
1393 {{vt,0}, {vt,2}, {vt,4}, {vt,6}, {vs,0}, {vs,2}, {vs,4}, {vs,6}}, /* pacl */
1394 {{vt,4}, {vs,4}, {vt,5}, {vs,5}, {vt,6}, {vs,6}, {vt,7}, {vs,7}}, /* mixh */
1395 {{vt,0}, {vs,0}, {vt,1}, {vs,1}, {vt,2}, {vs,2}, {vt,3}, {vs,3}} /* mixl */
1396 };
1397
1398 static const sh_map qh_shuffle[][4] = {
1399 {{vt,2}, {vs,2}, {vt,3}, {vs,3}}, /* mixh */
1400 {{vt,0}, {vs,0}, {vt,1}, {vs,1}}, /* mixl */
1401 {{vt,1}, {vt,3}, {vs,1}, {vs,3}}, /* pach */
1402 { }, /* RSVD */
1403 {{vt,1}, {vs,0}, {vt,3}, {vs,2}}, /* bfla */
1404 { }, /* RSVD */
1405 {{vt,2}, {vt,3}, {vs,2}, {vs,3}}, /* repa */
1406 {{vt,0}, {vt,1}, {vs,0}, {vs,1}} /* repb */
1407 };
1408
1409
1410 unsigned64
1411 mdmx_shuffle(sim_cpu *cpu,
1412 address_word cia,
1413 int shop,
1414 unsigned64 op1,
1415 unsigned64 op2)
1416 {
1417 unsigned64 result = 0;
1418 int i, s;
1419 int op;
1420
1421 if ((shop & 0x3) == 0x1) /* QH format. */
1422 {
1423 op = shop >> 2;
1424 s = 0;
1425 for (i = 0; i < 4; i++)
1426 {
1427 unsigned64 v;
1428
1429 switch (qh_shuffle[op][i].source)
1430 {
1431 case vs:
1432 v = op1;
1433 break;
1434 case vt:
1435 v = op2;
1436 break;
1437 default:
1438 Unpredictable ();
1439 v = 0;
1440 }
1441 result |= (((v >> 16*qh_shuffle[op][i].index) & 0xFFFF) << s);
1442 s += 16;
1443 }
1444 }
1445 else if ((shop & 0x1) == 0x0) /* OB format. */
1446 {
1447 op = shop >> 1;
1448 s = 0;
1449 for (i = 0; i < 8; i++)
1450 {
1451 unsigned8 b;
1452 unsigned int ishift = 8*ob_shuffle[op][i].index;
1453
1454 switch (ob_shuffle[op][i].source)
1455 {
1456 case vs:
1457 b = (op1 >> ishift) & 0xFF;
1458 break;
1459 case ss:
1460 b = ((op1 >> ishift) & 0x80) ? 0xFF : 0;
1461 break;
1462 case vt:
1463 b = (op2 >> ishift) & 0xFF;
1464 break;
1465 default:
1466 Unpredictable ();
1467 b = 0;
1468 }
1469 result |= ((unsigned64)b << s);
1470 s += 8;
1471 }
1472 }
1473 else
1474 Unpredictable ();
1475
1476 return result;
1477 }