* armemu.c (handle_v6_insn): Fix typo in sign extension test of the sext and sxtah...
[platform/upstream/binutils.git] / sim / arm / maverick.c
1 /*  maverick.c -- Cirrus/DSP co-processor interface.
2     Copyright (C) 2003, 2007 Free Software Foundation, Inc.
3     Contributed by Aldy Hernandez (aldyh@redhat.com).
4  
5     This program is free software; you can redistribute it and/or modify
6     it under the terms of the GNU General Public License as published by
7     the Free Software Foundation; either version 2 of the License, or
8     (at your option) any later version.
9  
10     This program is distributed in the hope that it will be useful,
11     but WITHOUT ANY WARRANTY; without even the implied warranty of
12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13     GNU General Public License for more details.
14  
15     You should have received a copy of the GNU General Public License
16     along with this program; if not, write to the Free Software
17     Foundation, Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */
18
19 #include <assert.h>
20 #include "armdefs.h"
21 #include "ansidecl.h"
22 #include "armemu.h"
23
24 /*#define CIRRUS_DEBUG 1        /**/
25 #if CIRRUS_DEBUG
26 #  define printfdbg printf
27 #else
28 #  define printfdbg printf_nothing
29 #endif
30
31 #define POS64(i) ( (~(i)) >> 63 )
32 #define NEG64(i) ( (i) >> 63 )
33
34 /* Define Co-Processor instruction handlers here.  */
35
36 /* Here's ARMulator's DSP definition.  A few things to note:
37    1) it has 16 64-bit registers and 4 72-bit accumulators
38    2) you can only access its registers with MCR and MRC.  */
39
40 /* We can't define these in here because this file might not be linked
41    unless the target is arm9e-*.  They are defined in wrapper.c.
42    Eventually the simulator should be made to handle any coprocessor
43    at run time.  */
44 struct maverick_regs
45 {
46   union
47   {
48     int i;
49     float f;
50   } upper;
51   
52   union
53   {
54     int i;
55     float f;
56   } lower;
57 };
58
59 union maverick_acc_regs
60 {
61   long double ld;               /* Acc registers are 72-bits.  */
62 };
63
64 struct maverick_regs DSPregs[16];
65 union maverick_acc_regs DSPacc[4];
66 ARMword DSPsc;
67
68 #define DEST_REG        (BITS (12, 15))
69 #define SRC1_REG        (BITS (16, 19))
70 #define SRC2_REG        (BITS (0, 3))
71
72 static int lsw_int_index, msw_int_index;
73 static int lsw_float_index, msw_float_index;
74
75 static double mv_getRegDouble (int);
76 static long long mv_getReg64int (int);
77 static void mv_setRegDouble (int, double val);
78 static void mv_setReg64int (int, long long val);
79
80 static union
81 {
82   double d;
83   long long ll;
84   int ints[2];
85 } reg_conv;
86
87 static void
88 printf_nothing (void * foo, ...)
89 {
90 }
91
92 static void
93 cirrus_not_implemented (char * insn)
94 {
95   fprintf (stderr, "Cirrus instruction '%s' not implemented.\n", insn);
96   fprintf (stderr, "aborting!\n");
97   
98   exit (1);
99 }
100
101 static unsigned
102 DSPInit (ARMul_State * state)
103 {
104   ARMul_ConsolePrint (state, ", DSP present");
105   return TRUE;
106 }
107
108 unsigned
109 DSPMRC4 (ARMul_State * state ATTRIBUTE_UNUSED,
110          unsigned      type  ATTRIBUTE_UNUSED,
111          ARMword       instr,
112          ARMword *     value)
113 {
114   switch (BITS (5, 7))
115     {
116     case 0: /* cfmvrdl */
117       /* Move lower half of a DF stored in a DSP reg into an Arm reg.  */
118       printfdbg ("cfmvrdl\n");
119       printfdbg ("\tlower half=0x%x\n", DSPregs[SRC1_REG].lower.i);
120       printfdbg ("\tentire thing=%g\n", mv_getRegDouble (SRC1_REG));
121       
122       *value = (ARMword) DSPregs[SRC1_REG].lower.i;
123       break;
124       
125     case 1: /* cfmvrdh */
126       /* Move upper half of a DF stored in a DSP reg into an Arm reg.  */
127       printfdbg ("cfmvrdh\n");
128       printfdbg ("\tupper half=0x%x\n", DSPregs[SRC1_REG].upper.i);
129       printfdbg ("\tentire thing=%g\n", mv_getRegDouble (SRC1_REG));
130       
131       *value = (ARMword) DSPregs[SRC1_REG].upper.i;
132       break;
133       
134     case 2: /* cfmvrs */
135       /* Move SF from upper half of a DSP register to an Arm register.  */
136       *value = (ARMword) DSPregs[SRC1_REG].upper.i;
137       printfdbg ("cfmvrs = mvf%d <-- %f\n",
138                  SRC1_REG,
139                  DSPregs[SRC1_REG].upper.f);
140       break;
141       
142 #ifdef doesnt_work
143     case 4: /* cfcmps */
144       {
145         float a, b;
146         int n, z, c, v;
147
148         a = DSPregs[SRC1_REG].upper.f;
149         b = DSPregs[SRC2_REG].upper.f;
150
151         printfdbg ("cfcmps\n");
152         printfdbg ("\tcomparing %f and %f\n", a, b);
153
154         z = a == b;             /* zero */
155         n = a != b;             /* negative */
156         v = a > b;              /* overflow */
157         c = 0;                  /* carry */
158         *value = (n << 31) | (z << 30) | (c << 29) | (v << 28);
159         break;
160       }
161       
162     case 5: /* cfcmpd */
163       {
164         double a, b;
165         int n, z, c, v;
166
167         a = mv_getRegDouble (SRC1_REG);
168         b = mv_getRegDouble (SRC2_REG);
169
170         printfdbg ("cfcmpd\n");
171         printfdbg ("\tcomparing %g and %g\n", a, b);
172
173         z = a == b;             /* zero */
174         n = a != b;             /* negative */
175         v = a > b;              /* overflow */
176         c = 0;                  /* carry */
177         *value = (n << 31) | (z << 30) | (c << 29) | (v << 28);
178         break;
179       }
180 #else
181       case 4: /* cfcmps */
182         {
183           float a, b;
184           int n, z, c, v;
185
186           a = DSPregs[SRC1_REG].upper.f;
187           b = DSPregs[SRC2_REG].upper.f;
188   
189           printfdbg ("cfcmps\n");
190           printfdbg ("\tcomparing %f and %f\n", a, b);
191
192           z = a == b;           /* zero */
193           n = a < b;            /* negative */
194           c = a > b;            /* carry */
195           v = 0;                /* fixme */
196           printfdbg ("\tz = %d, n = %d\n", z, n);
197           *value = (n << 31) | (z << 30) | (c << 29) | (v << 28);
198           break;
199         }
200         
201       case 5: /* cfcmpd */
202         {
203           double a, b;
204           int n, z, c, v;
205
206           a = mv_getRegDouble (SRC1_REG);
207           b = mv_getRegDouble (SRC2_REG);
208   
209           printfdbg ("cfcmpd\n");
210           printfdbg ("\tcomparing %g and %g\n", a, b);
211   
212           z = a == b;           /* zero */
213           n = a < b;            /* negative */
214           c = a > b;            /* carry */
215           v = 0;                /* fixme */
216           *value = (n << 31) | (z << 30) | (c << 29) | (v << 28);
217           break;
218         }
219 #endif
220     default:
221       fprintf (stderr, "unknown opcode in DSPMRC4 0x%x\n", instr);
222       cirrus_not_implemented ("unknown");
223       break;
224     }
225
226   return ARMul_DONE;
227 }
228
229 unsigned
230 DSPMRC5 (ARMul_State * state ATTRIBUTE_UNUSED,
231          unsigned      type  ATTRIBUTE_UNUSED,
232          ARMword       instr,
233          ARMword *     value)
234 {
235   switch (BITS (5, 7))
236     {
237     case 0: /* cfmvr64l */
238       /* Move lower half of 64bit int from Cirrus to Arm.  */
239       *value = (ARMword) DSPregs[SRC1_REG].lower.i;
240       printfdbg ("cfmvr64l ARM_REG = mvfx%d <-- %d\n",
241                  DEST_REG,
242                  (int) *value);
243       break;
244       
245     case 1: /* cfmvr64h */
246       /* Move upper half of 64bit int from Cirrus to Arm.  */
247       *value = (ARMword) DSPregs[SRC1_REG].upper.i;
248       printfdbg ("cfmvr64h <-- %d\n", (int) *value);
249       break;
250       
251     case 4: /* cfcmp32 */
252       {
253         int res;
254         int n, z, c, v;
255         unsigned int a, b;
256
257         printfdbg ("cfcmp32 mvfx%d - mvfx%d\n",
258                    SRC1_REG,
259                    SRC2_REG);
260
261         /* FIXME: see comment for cfcmps.  */
262         a = DSPregs[SRC1_REG].lower.i;
263         b = DSPregs[SRC2_REG].lower.i;
264
265         res = DSPregs[SRC1_REG].lower.i - DSPregs[SRC2_REG].lower.i;
266         /* zero */
267         z = res == 0;
268         /* negative */
269         n = res < 0;
270         /* overflow */
271         v = SubOverflow (DSPregs[SRC1_REG].lower.i, DSPregs[SRC2_REG].lower.i,
272                          res);
273         /* carry */
274         c = (NEG (a) && POS (b) ||
275              (NEG (a) && POS (res)) || (POS (b) && POS (res)));
276
277         *value = (n << 31) | (z << 30) | (c << 29) | (v << 28);
278         break;
279       }
280       
281     case 5: /* cfcmp64 */
282       {
283         long long res;
284         int n, z, c, v;
285         unsigned long long a, b;
286
287         printfdbg ("cfcmp64 mvdx%d - mvdx%d\n",
288                    SRC1_REG,
289                    SRC2_REG);
290
291         /* fixme: see comment for cfcmps.  */
292
293         a = mv_getReg64int (SRC1_REG);
294         b = mv_getReg64int (SRC2_REG);
295
296         res = mv_getReg64int (SRC1_REG) - mv_getReg64int (SRC2_REG);
297         /* zero */
298         z = res == 0;
299         /* negative */
300         n = res < 0;
301         /* overflow */
302         v = ((NEG64 (a) && POS64 (b) && POS64 (res))
303              || (POS64 (a) && NEG64 (b) && NEG64 (res)));
304         /* carry */
305         c = (NEG64 (a) && POS64 (b) ||
306              (NEG64 (a) && POS64 (res)) || (POS64 (b) && POS64 (res)));
307
308         *value = (n << 31) | (z << 30) | (c << 29) | (v << 28);
309         break;
310       }
311       
312     default:
313       fprintf (stderr, "unknown opcode in DSPMRC5 0x%x\n", instr);
314       cirrus_not_implemented ("unknown");
315       break;
316     }
317
318   return ARMul_DONE;
319 }
320
321 unsigned
322 DSPMRC6 (ARMul_State * state ATTRIBUTE_UNUSED,
323          unsigned      type  ATTRIBUTE_UNUSED,
324          ARMword       instr,
325          ARMword *     value)
326 {
327   switch (BITS (5, 7))
328     {
329     case 0: /* cfmval32 */
330       cirrus_not_implemented ("cfmval32");
331       break;
332       
333     case 1: /* cfmvam32 */
334       cirrus_not_implemented ("cfmvam32");
335       break;
336       
337     case 2: /* cfmvah32 */
338       cirrus_not_implemented ("cfmvah32");
339       break;
340       
341     case 3: /* cfmva32 */
342       cirrus_not_implemented ("cfmva32");
343       break;
344       
345     case 4: /* cfmva64 */
346       cirrus_not_implemented ("cfmva64");
347       break;
348       
349     case 5: /* cfmvsc32 */
350       cirrus_not_implemented ("cfmvsc32");
351       break;
352       
353     default:
354       fprintf (stderr, "unknown opcode in DSPMRC6 0x%x\n", instr);
355       cirrus_not_implemented ("unknown");
356       break;
357     }
358
359   return ARMul_DONE;
360 }
361
362 unsigned
363 DSPMCR4 (ARMul_State * state,
364          unsigned      type ATTRIBUTE_UNUSED,
365          ARMword       instr,
366          ARMword       value)
367 {
368   switch (BITS (5, 7))
369     {
370     case 0: /* cfmvdlr */
371       /* Move the lower half of a DF value from an Arm register into
372          the lower half of a Cirrus register.  */
373       printfdbg ("cfmvdlr <-- 0x%x\n", (int) value);
374       DSPregs[SRC1_REG].lower.i = (int) value;
375       break;
376       
377     case 1: /* cfmvdhr */
378       /* Move the upper half of a DF value from an Arm register into
379          the upper half of a Cirrus register.  */
380       printfdbg ("cfmvdhr <-- 0x%x\n", (int) value);
381       DSPregs[SRC1_REG].upper.i = (int) value;
382       break;
383       
384     case 2: /* cfmvsr */
385       /* Move SF from Arm register into upper half of Cirrus register.  */
386       printfdbg ("cfmvsr <-- 0x%x\n", (int) value);
387       DSPregs[SRC1_REG].upper.i = (int) value;
388       break;
389       
390     default:
391       fprintf (stderr, "unknown opcode in DSPMCR4 0x%x\n", instr);
392       cirrus_not_implemented ("unknown");
393       break;
394     }
395
396   return ARMul_DONE;
397 }
398
399 unsigned
400 DSPMCR5 (ARMul_State * state,
401          unsigned      type   ATTRIBUTE_UNUSED,
402          ARMword       instr,
403          ARMword       value)
404 {
405   union
406   {
407     int s;
408     unsigned int us;
409   } val;
410
411   switch (BITS (5, 7))
412     {
413     case 0: /* cfmv64lr */
414       /* Move lower half of a 64bit int from an ARM register into the
415          lower half of a DSP register and sign extend it.  */
416       printfdbg ("cfmv64lr mvdx%d <-- 0x%x\n", SRC1_REG, (int) value);
417       DSPregs[SRC1_REG].lower.i = (int) value;
418       break;
419       
420     case 1: /* cfmv64hr */
421       /* Move upper half of a 64bit int from an ARM register into the
422          upper half of a DSP register.  */
423       printfdbg ("cfmv64hr ARM_REG = mvfx%d <-- 0x%x\n",
424                  SRC1_REG,
425                  (int) value);
426       DSPregs[SRC1_REG].upper.i = (int) value;
427       break;
428       
429     case 2: /* cfrshl32 */
430       printfdbg ("cfrshl32\n");
431       val.us = value;
432       if (val.s > 0)
433         DSPregs[SRC2_REG].lower.i = DSPregs[SRC1_REG].lower.i << value;
434       else
435         DSPregs[SRC2_REG].lower.i = DSPregs[SRC1_REG].lower.i >> -value;
436       break;
437       
438     case 3: /* cfrshl64 */
439       printfdbg ("cfrshl64\n");
440       val.us = value;
441       if (val.s > 0)
442         mv_setReg64int (SRC2_REG, mv_getReg64int (SRC1_REG) << value);
443       else
444         mv_setReg64int (SRC2_REG, mv_getReg64int (SRC1_REG) >> -value);
445       break;
446       
447     default:
448       fprintf (stderr, "unknown opcode in DSPMCR5 0x%x\n", instr);
449       cirrus_not_implemented ("unknown");
450       break;
451     }
452
453   return ARMul_DONE;
454 }
455
456 unsigned
457 DSPMCR6 (ARMul_State * state,
458          unsigned      type   ATTRIBUTE_UNUSED,
459          ARMword       instr,
460          ARMword       value)
461 {
462   switch (BITS (5, 7))
463     {
464     case 0: /* cfmv32al */
465       cirrus_not_implemented ("cfmv32al");
466       break;
467       
468     case 1: /* cfmv32am */
469       cirrus_not_implemented ("cfmv32am");
470       break;
471       
472     case 2: /* cfmv32ah */
473       cirrus_not_implemented ("cfmv32ah");
474       break;
475       
476     case 3: /* cfmv32a */
477       cirrus_not_implemented ("cfmv32a");
478       break;
479       
480     case 4: /* cfmv64a */
481       cirrus_not_implemented ("cfmv64a");
482       break;
483       
484     case 5: /* cfmv32sc */
485       cirrus_not_implemented ("cfmv32sc");
486       break;
487       
488     default:
489       fprintf (stderr, "unknown opcode in DSPMCR6 0x%x\n", instr);
490       cirrus_not_implemented ("unknown");
491       break;
492     }
493
494   return ARMul_DONE;
495 }
496
497 unsigned
498 DSPLDC4 (ARMul_State * state ATTRIBUTE_UNUSED,
499          unsigned      type,
500          ARMword       instr,
501          ARMword       data)
502 {
503   static unsigned words;
504
505   if (type != ARMul_DATA)
506     {
507       words = 0;
508       return ARMul_DONE;
509     }
510   
511   if (BIT (22))
512     {                           /* it's a long access, get two words */
513       /* cfldrd */
514
515       printfdbg ("cfldrd: %x (words = %d) (bigend = %d) DESTREG = %d\n",
516                  data, words, state->bigendSig, DEST_REG);
517       
518       if (words == 0)
519         {
520           if (state->bigendSig)
521             DSPregs[DEST_REG].upper.i = (int) data;
522           else
523             DSPregs[DEST_REG].lower.i = (int) data;
524         }
525       else
526         {
527           if (state->bigendSig)
528             DSPregs[DEST_REG].lower.i = (int) data;
529           else
530             DSPregs[DEST_REG].upper.i = (int) data;
531         }
532       
533       ++ words;
534       
535       if (words == 2)
536         {
537           printfdbg ("\tmvd%d <-- mem = %g\n", DEST_REG,
538                      mv_getRegDouble (DEST_REG));
539           
540           return ARMul_DONE;
541         }
542       else
543         return ARMul_INC;
544     }
545   else
546     {
547       /* Get just one word.  */
548       
549       /* cfldrs */
550       printfdbg ("cfldrs\n");
551
552       DSPregs[DEST_REG].upper.i = (int) data;
553
554       printfdbg ("\tmvf%d <-- mem = %f\n", DEST_REG,
555                  DSPregs[DEST_REG].upper.f);
556
557       return ARMul_DONE;
558     }
559 }
560
561 unsigned
562 DSPLDC5 (ARMul_State * state ATTRIBUTE_UNUSED,
563          unsigned      type,
564          ARMword       instr,
565          ARMword       data)
566 {
567   static unsigned words;
568
569   if (type != ARMul_DATA)
570     {
571       words = 0;
572       return ARMul_DONE;
573     }
574   
575   if (BIT (22))
576     {
577       /* It's a long access, get two words.  */
578       
579       /* cfldr64 */
580       printfdbg ("cfldr64: %d\n", data);
581
582       if (words == 0)
583         {
584           if (state->bigendSig)
585             DSPregs[DEST_REG].upper.i = (int) data;
586           else
587             DSPregs[DEST_REG].lower.i = (int) data;
588         }
589       else
590         {
591           if (state->bigendSig)
592             DSPregs[DEST_REG].lower.i = (int) data;
593           else
594             DSPregs[DEST_REG].upper.i = (int) data;
595         }
596       
597       ++ words;
598       
599       if (words == 2)
600         {
601           printfdbg ("\tmvdx%d <-- mem = %lld\n", DEST_REG,
602                      mv_getReg64int (DEST_REG));
603           
604           return ARMul_DONE;
605         }
606       else
607         return ARMul_INC;
608     }
609   else
610     {
611       /* Get just one word.  */
612       
613       /* cfldr32 */
614       printfdbg ("cfldr32 mvfx%d <-- %d\n", DEST_REG, (int) data);
615       
616       /* 32bit ints should be sign extended to 64bits when loaded.  */
617       mv_setReg64int (DEST_REG, (long long) data);
618
619       return ARMul_DONE;
620     }
621 }
622
623 unsigned
624 DSPSTC4 (ARMul_State * state ATTRIBUTE_UNUSED,
625          unsigned      type,
626          ARMword       instr,
627          ARMword *     data)
628 {
629   static unsigned words;
630
631   if (type != ARMul_DATA)
632     {
633       words = 0;
634       return ARMul_DONE;
635     }
636   
637   if (BIT (22))
638     {
639       /* It's a long access, get two words.  */
640       /* cfstrd */
641       printfdbg ("cfstrd\n");
642
643       if (words == 0)
644         {
645           if (state->bigendSig)
646             *data = (ARMword) DSPregs[DEST_REG].upper.i;
647           else
648             *data = (ARMword) DSPregs[DEST_REG].lower.i;
649         }
650       else
651         {
652           if (state->bigendSig)
653             *data = (ARMword) DSPregs[DEST_REG].lower.i;
654           else
655             *data = (ARMword) DSPregs[DEST_REG].upper.i;
656         }
657       
658       ++ words;
659       
660       if (words == 2)
661         {
662           printfdbg ("\tmem = mvd%d = %g\n", DEST_REG,
663                      mv_getRegDouble (DEST_REG));
664           
665           return ARMul_DONE;
666         }
667       else
668         return ARMul_INC;
669     }
670   else
671     {
672       /* Get just one word.  */
673       /* cfstrs */
674       printfdbg ("cfstrs mvf%d <-- %f\n", DEST_REG,
675                  DSPregs[DEST_REG].upper.f);
676
677       *data = (ARMword) DSPregs[DEST_REG].upper.i;
678
679       return ARMul_DONE;
680     }
681 }
682
683 unsigned
684 DSPSTC5 (ARMul_State * state ATTRIBUTE_UNUSED,
685          unsigned      type,
686          ARMword       instr,
687          ARMword *     data)
688 {
689   static unsigned words;
690
691   if (type != ARMul_DATA)
692     {
693       words = 0;
694       return ARMul_DONE;
695     }
696   
697   if (BIT (22))
698     {
699       /* It's a long access, store two words.  */
700       /* cfstr64 */
701       printfdbg ("cfstr64\n");
702
703       if (words == 0)
704         {
705           if (state->bigendSig)
706             *data = (ARMword) DSPregs[DEST_REG].upper.i;
707           else
708             *data = (ARMword) DSPregs[DEST_REG].lower.i;
709         }
710       else
711         {
712           if (state->bigendSig)
713             *data = (ARMword) DSPregs[DEST_REG].lower.i;
714           else
715             *data = (ARMword) DSPregs[DEST_REG].upper.i;
716         }
717       
718       ++ words;
719       
720       if (words == 2)
721         {
722           printfdbg ("\tmem = mvd%d = %lld\n", DEST_REG,
723                      mv_getReg64int (DEST_REG));
724           
725           return ARMul_DONE;
726         }
727       else
728         return ARMul_INC;
729     }
730   else
731     {
732       /* Store just one word.  */
733       /* cfstr32 */
734       *data = (ARMword) DSPregs[DEST_REG].lower.i;
735       
736       printfdbg ("cfstr32 MEM = %d\n", (int) *data);
737
738       return ARMul_DONE;
739     }
740 }
741
742 unsigned
743 DSPCDP4 (ARMul_State * state,
744          unsigned      type,
745          ARMword       instr)
746 {
747   int opcode2;
748
749   opcode2 = BITS (5,7);
750
751   switch (BITS (20,21))
752     {
753     case 0:
754       switch (opcode2)
755         {
756         case 0: /* cfcpys */
757           printfdbg ("cfcpys mvf%d = mvf%d = %f\n",
758                      DEST_REG,
759                      SRC1_REG,
760                      DSPregs[SRC1_REG].upper.f);
761           DSPregs[DEST_REG].upper.f = DSPregs[SRC1_REG].upper.f;
762           break;
763           
764         case 1: /* cfcpyd */
765           printfdbg ("cfcpyd mvd%d = mvd%d = %g\n",
766                      DEST_REG,
767                      SRC1_REG,
768                      mv_getRegDouble (SRC1_REG));
769           mv_setRegDouble (DEST_REG, mv_getRegDouble (SRC1_REG));
770           break;
771           
772         case 2: /* cfcvtds */
773           printfdbg ("cfcvtds mvf%d = (float) mvd%d = %f\n",
774                      DEST_REG,
775                      SRC1_REG,
776                      (float) mv_getRegDouble (SRC1_REG));
777           DSPregs[DEST_REG].upper.f = (float) mv_getRegDouble (SRC1_REG);
778           break;
779           
780         case 3: /* cfcvtsd */
781           printfdbg ("cfcvtsd mvd%d = mvf%d = %g\n",
782                      DEST_REG,
783                      SRC1_REG,
784                      (double) DSPregs[SRC1_REG].upper.f);
785           mv_setRegDouble (DEST_REG, (double) DSPregs[SRC1_REG].upper.f);
786           break;
787           
788         case 4: /* cfcvt32s */
789           printfdbg ("cfcvt32s mvf%d = mvfx%d = %f\n",
790                      DEST_REG,
791                      SRC1_REG,
792                      (float) DSPregs[SRC1_REG].lower.i);
793           DSPregs[DEST_REG].upper.f = (float) DSPregs[SRC1_REG].lower.i;
794           break;
795           
796         case 5: /* cfcvt32d */
797           printfdbg ("cfcvt32d mvd%d = mvfx%d = %g\n",
798                      DEST_REG,
799                      SRC1_REG,
800                      (double) DSPregs[SRC1_REG].lower.i);
801           mv_setRegDouble (DEST_REG, (double) DSPregs[SRC1_REG].lower.i);
802           break;
803           
804         case 6: /* cfcvt64s */
805           printfdbg ("cfcvt64s mvf%d = mvdx%d = %f\n",
806                      DEST_REG,
807                      SRC1_REG,
808                      (float) mv_getReg64int (SRC1_REG));
809           DSPregs[DEST_REG].upper.f = (float) mv_getReg64int (SRC1_REG);
810           break;
811           
812         case 7: /* cfcvt64d */
813           printfdbg ("cfcvt64d mvd%d = mvdx%d = %g\n",
814                      DEST_REG,
815                      SRC1_REG,
816                      (double) mv_getReg64int (SRC1_REG));
817           mv_setRegDouble (DEST_REG, (double) mv_getReg64int (SRC1_REG));
818           break;
819         }
820       break;
821
822     case 1:
823       switch (opcode2)
824         {
825         case 0: /* cfmuls */
826           printfdbg ("cfmuls mvf%d = mvf%d = %f\n",
827                      DEST_REG,
828                      SRC1_REG,
829                      DSPregs[SRC1_REG].upper.f * DSPregs[SRC2_REG].upper.f);
830                      
831           DSPregs[DEST_REG].upper.f = DSPregs[SRC1_REG].upper.f
832             * DSPregs[SRC2_REG].upper.f;
833           break;
834           
835         case 1: /* cfmuld */
836           printfdbg ("cfmuld mvd%d = mvd%d = %g\n",
837                      DEST_REG,
838                      SRC1_REG,
839                      mv_getRegDouble (SRC1_REG) * mv_getRegDouble (SRC2_REG));
840
841           mv_setRegDouble (DEST_REG,
842                            mv_getRegDouble (SRC1_REG)
843                            * mv_getRegDouble (SRC2_REG));
844           break;
845           
846         default:
847           fprintf (stderr, "unknown opcode in DSPCDP4 0x%x\n", instr);
848           cirrus_not_implemented ("unknown");
849           break;
850         }
851       break;
852
853     case 3:
854       switch (opcode2)
855         {
856         case 0: /* cfabss */
857           DSPregs[DEST_REG].upper.f = (DSPregs[SRC1_REG].upper.f < 0.0F ?
858                                        -DSPregs[SRC1_REG].upper.f
859                                        : DSPregs[SRC1_REG].upper.f);
860           printfdbg ("cfabss mvf%d = |mvf%d| = %f\n",
861                      DEST_REG,
862                      SRC1_REG,
863                      DSPregs[DEST_REG].upper.f);
864           break;
865           
866         case 1: /* cfabsd */
867           mv_setRegDouble (DEST_REG,
868                            (mv_getRegDouble (SRC1_REG) < 0.0 ?
869                             -mv_getRegDouble (SRC1_REG)
870                             : mv_getRegDouble (SRC1_REG)));
871           printfdbg ("cfabsd mvd%d = |mvd%d| = %g\n",
872                      DEST_REG,
873                      SRC1_REG,
874                      mv_getRegDouble (DEST_REG));
875           break;
876           
877         case 2: /* cfnegs */
878           DSPregs[DEST_REG].upper.f = -DSPregs[SRC1_REG].upper.f;
879           printfdbg ("cfnegs mvf%d = -mvf%d = %f\n",
880                      DEST_REG,
881                      SRC1_REG,
882                      DSPregs[DEST_REG].upper.f);
883           break;
884           
885         case 3: /* cfnegd */
886           mv_setRegDouble (DEST_REG,
887                            -mv_getRegDouble (SRC1_REG));
888           printfdbg ("cfnegd mvd%d = -mvd%d = %g\n",
889                      DEST_REG,
890                      mv_getRegDouble (DEST_REG));
891           break;
892           
893         case 4: /* cfadds */
894           DSPregs[DEST_REG].upper.f = DSPregs[SRC1_REG].upper.f
895             + DSPregs[SRC2_REG].upper.f;
896           printfdbg ("cfadds mvf%d = mvf%d + mvf%d = %f\n",
897                      DEST_REG,
898                      SRC1_REG,
899                      SRC2_REG,
900                      DSPregs[DEST_REG].upper.f);
901           break;
902           
903         case 5: /* cfaddd */
904           mv_setRegDouble (DEST_REG,
905                            mv_getRegDouble (SRC1_REG)
906                            + mv_getRegDouble (SRC2_REG));
907           printfdbg ("cfaddd: mvd%d = mvd%d + mvd%d = %g\n",
908                      DEST_REG,
909                      SRC1_REG,
910                      SRC2_REG,
911                      mv_getRegDouble (DEST_REG));
912           break;
913           
914         case 6: /* cfsubs */
915           DSPregs[DEST_REG].upper.f = DSPregs[SRC1_REG].upper.f
916             - DSPregs[SRC2_REG].upper.f;
917           printfdbg ("cfsubs: mvf%d = mvf%d - mvf%d = %f\n",
918                      DEST_REG,
919                      SRC1_REG,
920                      SRC2_REG,
921                      DSPregs[DEST_REG].upper.f);
922           break;
923           
924         case 7: /* cfsubd */
925           mv_setRegDouble (DEST_REG,
926                            mv_getRegDouble (SRC1_REG)
927                            - mv_getRegDouble (SRC2_REG));
928           printfdbg ("cfsubd: mvd%d = mvd%d - mvd%d = %g\n",
929                      DEST_REG,
930                      SRC1_REG,
931                      SRC2_REG,
932                      mv_getRegDouble (DEST_REG));
933           break;
934         }
935       break;
936
937     default:
938       fprintf (stderr, "unknown opcode in DSPCDP4 0x%x\n", instr);
939       cirrus_not_implemented ("unknown");
940       break;
941     }
942
943   return ARMul_DONE;
944 }
945
946 unsigned
947 DSPCDP5 (ARMul_State * state,
948          unsigned      type,
949          ARMword       instr)
950 {
951    int opcode2;
952    char shift;
953
954    opcode2 = BITS (5,7);
955
956    /* Shift constants are 7bit signed numbers in bits 0..3|5..7.  */
957    shift = BITS (0, 3) | (BITS (5, 7)) << 4;
958    if (shift & 0x40)
959      shift |= 0xc0;
960
961    switch (BITS (20,21))
962      {
963      case 0:
964        /* cfsh32 */
965        printfdbg ("cfsh32 %s amount=%d\n", shift < 0 ? "right" : "left",
966                   shift);
967        if (shift < 0)
968          /* Negative shift is a right shift.  */
969          DSPregs[DEST_REG].lower.i = DSPregs[SRC1_REG].lower.i >> -shift;
970        else
971          /* Positive shift is a left shift.  */
972          DSPregs[DEST_REG].lower.i = DSPregs[SRC1_REG].lower.i << shift;
973        break;
974
975      case 1:
976        switch (opcode2)
977          {
978          case 0: /* cfmul32 */
979            DSPregs[DEST_REG].lower.i = DSPregs[SRC1_REG].lower.i
980              * DSPregs[SRC2_REG].lower.i;
981            printfdbg ("cfmul32 mvfx%d = mvfx%d * mvfx%d = %d\n",
982                       DEST_REG,
983                       SRC1_REG,
984                       SRC2_REG,
985                       DSPregs[DEST_REG].lower.i);
986            break;
987            
988          case 1: /* cfmul64 */
989            mv_setReg64int (DEST_REG,
990                            mv_getReg64int (SRC1_REG)
991                            * mv_getReg64int (SRC2_REG));
992            printfdbg ("cfmul64 mvdx%d = mvdx%d * mvdx%d = %lld\n",
993                       DEST_REG,
994                       SRC1_REG,
995                       SRC2_REG,
996                       mv_getReg64int (DEST_REG));
997            break;
998            
999          case 2: /* cfmac32 */
1000            DSPregs[DEST_REG].lower.i
1001              += DSPregs[SRC1_REG].lower.i * DSPregs[SRC2_REG].lower.i;
1002            printfdbg ("cfmac32 mvfx%d += mvfx%d * mvfx%d = %d\n",
1003                       DEST_REG,
1004                       SRC1_REG,
1005                       SRC2_REG,
1006                       DSPregs[DEST_REG].lower.i);
1007            break;
1008            
1009          case 3: /* cfmsc32 */
1010            DSPregs[DEST_REG].lower.i
1011              -= DSPregs[SRC1_REG].lower.i * DSPregs[SRC2_REG].lower.i;
1012            printfdbg ("cfmsc32 mvfx%d -= mvfx%d * mvfx%d = %d\n",
1013                       DEST_REG,
1014                       SRC1_REG,
1015                       SRC2_REG,
1016                       DSPregs[DEST_REG].lower.i);
1017            break;
1018            
1019          case 4: /* cfcvts32 */
1020            /* fixme: this should round */
1021            DSPregs[DEST_REG].lower.i = (int) DSPregs[SRC1_REG].upper.f;
1022            printfdbg ("cfcvts32 mvfx%d = mvf%d = %d\n",
1023                       DEST_REG,
1024                       SRC1_REG,
1025                       DSPregs[DEST_REG].lower.i);
1026            break;
1027            
1028          case 5: /* cfcvtd32 */
1029            /* fixme: this should round */
1030            DSPregs[DEST_REG].lower.i = (int) mv_getRegDouble (SRC1_REG);
1031            printfdbg ("cfcvtd32 mvdx%d = mvd%d = %d\n",
1032                       DEST_REG,
1033                       SRC1_REG,
1034                       DSPregs[DEST_REG].lower.i);
1035            break;
1036            
1037          case 6: /* cftruncs32 */
1038            DSPregs[DEST_REG].lower.i = (int) DSPregs[SRC1_REG].upper.f;
1039            printfdbg ("cftruncs32 mvfx%d = mvf%d = %d\n",
1040                       DEST_REG,
1041                       SRC1_REG,
1042                       DSPregs[DEST_REG].lower.i);
1043            break;
1044            
1045          case 7: /* cftruncd32 */
1046            DSPregs[DEST_REG].lower.i = (int) mv_getRegDouble (SRC1_REG);
1047            printfdbg ("cftruncd32 mvfx%d = mvd%d = %d\n",
1048                       DEST_REG,
1049                       SRC1_REG,
1050                       DSPregs[DEST_REG].lower.i);
1051            break;
1052          }
1053        break;
1054
1055      case 2:
1056        /* cfsh64 */
1057        printfdbg ("cfsh64\n");
1058        
1059        if (shift < 0)
1060          /* Negative shift is a right shift.  */
1061          mv_setReg64int (DEST_REG,
1062                          mv_getReg64int (SRC1_REG) >> -shift);
1063        else
1064          /* Positive shift is a left shift.  */
1065          mv_setReg64int (DEST_REG,
1066                          mv_getReg64int (SRC1_REG) << shift);
1067        printfdbg ("\t%llx\n", mv_getReg64int(DEST_REG));
1068        break;
1069
1070      case 3:
1071        switch (opcode2)
1072          {
1073          case 0: /* cfabs32 */
1074            DSPregs[DEST_REG].lower.i = (DSPregs[SRC1_REG].lower.i < 0
1075              ? -DSPregs[SRC1_REG].lower.i : DSPregs[SRC1_REG].lower.i);
1076            printfdbg ("cfabs32 mvfx%d = |mvfx%d| = %d\n",
1077                       DEST_REG,
1078                       SRC1_REG,
1079                       SRC2_REG,
1080                       DSPregs[DEST_REG].lower.i);
1081            break;
1082            
1083          case 1: /* cfabs64 */
1084            mv_setReg64int (DEST_REG,
1085                            (mv_getReg64int (SRC1_REG) < 0
1086                             ? -mv_getReg64int (SRC1_REG)
1087                             : mv_getReg64int (SRC1_REG)));
1088            printfdbg ("cfabs64 mvdx%d = |mvdx%d| = %lld\n",
1089                       DEST_REG,
1090                       SRC1_REG,
1091                       SRC2_REG,
1092                       mv_getReg64int (DEST_REG));
1093            break;
1094            
1095          case 2: /* cfneg32 */
1096            DSPregs[DEST_REG].lower.i = -DSPregs[SRC1_REG].lower.i;
1097            printfdbg ("cfneg32 mvfx%d = -mvfx%d = %d\n",
1098                       DEST_REG,
1099                       SRC1_REG,
1100                       SRC2_REG,
1101                       DSPregs[DEST_REG].lower.i);
1102            break;
1103            
1104          case 3: /* cfneg64 */
1105            mv_setReg64int (DEST_REG, -mv_getReg64int (SRC1_REG));
1106            printfdbg ("cfneg64 mvdx%d = -mvdx%d = %lld\n",
1107                       DEST_REG,
1108                       SRC1_REG,
1109                       SRC2_REG,
1110                       mv_getReg64int (DEST_REG));
1111            break;
1112            
1113          case 4: /* cfadd32 */
1114            DSPregs[DEST_REG].lower.i = DSPregs[SRC1_REG].lower.i
1115              + DSPregs[SRC2_REG].lower.i;
1116            printfdbg ("cfadd32 mvfx%d = mvfx%d + mvfx%d = %d\n",
1117                       DEST_REG,
1118                       SRC1_REG,
1119                       SRC2_REG,
1120                       DSPregs[DEST_REG].lower.i);
1121            break;
1122            
1123          case 5: /* cfadd64 */
1124            mv_setReg64int (DEST_REG,
1125                            mv_getReg64int (SRC1_REG)
1126                            + mv_getReg64int (SRC2_REG));
1127            printfdbg ("cfadd64 mvdx%d = mvdx%d + mvdx%d = %lld\n",
1128                       DEST_REG,
1129                       SRC1_REG,
1130                       SRC2_REG,
1131                       mv_getReg64int (DEST_REG));
1132            break;
1133            
1134          case 6: /* cfsub32 */
1135            DSPregs[DEST_REG].lower.i = DSPregs[SRC1_REG].lower.i
1136              - DSPregs[SRC2_REG].lower.i;
1137            printfdbg ("cfsub32 mvfx%d = mvfx%d - mvfx%d = %d\n",
1138                       DEST_REG,
1139                       SRC1_REG,
1140                       SRC2_REG,
1141                       DSPregs[DEST_REG].lower.i);
1142            break;
1143            
1144          case 7: /* cfsub64 */
1145            mv_setReg64int (DEST_REG,
1146                            mv_getReg64int (SRC1_REG)
1147                            - mv_getReg64int (SRC2_REG));
1148            printfdbg ("cfsub64 mvdx%d = mvdx%d - mvdx%d = %d\n",
1149                       DEST_REG,
1150                       SRC1_REG,
1151                       SRC2_REG,
1152                       mv_getReg64int (DEST_REG));
1153            break;
1154          }
1155        break;
1156
1157      default:
1158        fprintf (stderr, "unknown opcode in DSPCDP5 0x%x\n", instr);
1159        cirrus_not_implemented ("unknown");
1160        break;
1161      }
1162
1163   return ARMul_DONE;
1164 }
1165
1166 unsigned
1167 DSPCDP6 (ARMul_State * state,
1168          unsigned      type,
1169          ARMword       instr)
1170 {
1171    int opcode2;
1172
1173    opcode2 = BITS (5,7);
1174
1175    switch (BITS (20,21))
1176      {
1177      case 0:
1178        /* cfmadd32 */
1179        cirrus_not_implemented ("cfmadd32");
1180        break;
1181        
1182      case 1:
1183        /* cfmsub32 */
1184        cirrus_not_implemented ("cfmsub32");
1185        break;
1186        
1187      case 2:
1188        /* cfmadda32 */
1189        cirrus_not_implemented ("cfmadda32");
1190        break;
1191        
1192      case 3:
1193        /* cfmsuba32 */
1194        cirrus_not_implemented ("cfmsuba32");
1195        break;
1196
1197      default:
1198        fprintf (stderr, "unknown opcode in DSPCDP6 0x%x\n", instr);
1199      }
1200
1201    return ARMul_DONE;
1202 }
1203
1204 /* Conversion functions.
1205
1206    32-bit integers are stored in the LOWER half of a 64-bit physical
1207    register.
1208
1209    Single precision floats are stored in the UPPER half of a 64-bit
1210    physical register.  */
1211
1212 static double
1213 mv_getRegDouble (int regnum)
1214 {
1215   reg_conv.ints[lsw_float_index] = DSPregs[regnum].upper.i;
1216   reg_conv.ints[msw_float_index] = DSPregs[regnum].lower.i;
1217   return reg_conv.d;
1218 }
1219
1220 static void
1221 mv_setRegDouble (int regnum, double val)
1222 {
1223   reg_conv.d = val;
1224   DSPregs[regnum].upper.i = reg_conv.ints[lsw_float_index];
1225   DSPregs[regnum].lower.i = reg_conv.ints[msw_float_index];
1226 }
1227
1228 static long long
1229 mv_getReg64int (int regnum)
1230 {
1231   reg_conv.ints[lsw_int_index] = DSPregs[regnum].lower.i;
1232   reg_conv.ints[msw_int_index] = DSPregs[regnum].upper.i;
1233   return reg_conv.ll;
1234 }
1235
1236 static void
1237 mv_setReg64int (int regnum, long long val)
1238 {
1239   reg_conv.ll = val;
1240   DSPregs[regnum].lower.i = reg_conv.ints[lsw_int_index];
1241   DSPregs[regnum].upper.i = reg_conv.ints[msw_int_index];
1242 }
1243
1244 /* Compute LSW in a double and a long long.  */
1245
1246 void
1247 mv_compute_host_endianness (ARMul_State * state)
1248 {
1249   static union
1250   {
1251     long long ll;
1252     long ints[2];
1253     long i;
1254     double d;
1255     float floats[2];
1256     float f;
1257   } conv;
1258
1259   /* Calculate where's the LSW in a 64bit int.  */
1260   conv.ll = 45;
1261   
1262   if (conv.ints[0] == 0)
1263     {
1264       msw_int_index = 0;
1265       lsw_int_index = 1;
1266     }
1267   else
1268     {
1269       assert (conv.ints[1] == 0);
1270       msw_int_index = 1;
1271       lsw_int_index = 0;
1272     }
1273
1274   /* Calculate where's the LSW in a double.  */
1275   conv.d = 3.0;
1276   
1277   if (conv.ints[0] == 0)
1278     {
1279       msw_float_index = 0;
1280       lsw_float_index = 1;
1281     }
1282   else
1283     {
1284       assert (conv.ints[1] == 0);
1285       msw_float_index = 1;
1286       lsw_float_index = 0;
1287     }
1288
1289   printfdbg ("lsw_int_index   %d\n", lsw_int_index);
1290   printfdbg ("lsw_float_index %d\n", lsw_float_index);
1291 }