INSTALL_PROG -> INSTALL
[platform/upstream/binutils.git] / binutils / m68k-pinsn.c
1 /* Print m68k instructions for objdump
2    Copyright (C) 1986, 1987, 1989, 1991 Free Software Foundation, Inc.
3
4
5 This file is part of the binutils.
6
7 The binutils are free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 The binutils are distributed in the hope that they will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with the binutils; see the file COPYING.  If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
20
21
22 #include "bfd.h"
23 #include "sysdep.h"
24 #include <stdio.h>
25 #include "opcode/m68k.h"
26
27 /* Sign-extend an (unsigned char). */
28 #if __STDC__ == 1
29 #define COERCE_SIGNED_CHAR(ch) ((signed char)(ch))
30 #else
31 #define COERCE_SIGNED_CHAR(ch) ((int)(((ch) ^ 0x80) & 0xFF) - 128)
32 #endif
33
34 extern void print_address();
35
36 /* 68k instructions are never longer than this many bytes.  */
37 #define MAXLEN 22
38
39 /* Number of elements in the opcode table.  */
40 #define NOPCODES (sizeof m68k_opcodes / sizeof m68k_opcodes[0])
41
42 extern char *reg_names[];
43 char *fpcr_names[] = { "", "fpiar", "fpsr", "fpiar/fpsr", "fpcr",
44                      "fpiar/fpcr", "fpsr/fpcr", "fpiar-fpcr"};
45
46 char *reg_names[] = {"d0", "d1", "d2", "d3", "d4", "d5", "d6", "d7", "a0", "a1", "a2", "a3", "a4", "a5", "fp", "sp", "ps", "pc"};
47 static unsigned char *print_insn_arg ();
48 static unsigned char *print_indexed ();
49 static void print_base ();
50 static int fetch_arg ();
51
52 #define NEXTBYTE(p)  (p += 2, COERCE_SIGNED_CHAR(p[-1]))
53
54 #define NEXTWORD(p)  \
55   (p += 2, ((((char *)p)[-2]) << 8) + p[-1])
56
57 #define NEXTLONG(p)  \
58   (p += 4, (((((p[-4] << 8) + p[-3]) << 8) + p[-2]) << 8) + p[-1])
59
60 #define NEXTSINGLE(p) \
61   (p += 4, *((float *)(p - 4)))
62
63 #define NEXTDOUBLE(p) \
64   (p += 8, *((double *)(p - 8)))
65
66 #define NEXTEXTEND(p) \
67   (p += 12, 0.0)        /* Need a function to convert from extended to double
68                            precision... */
69
70 #define NEXTPACKED(p) \
71   (p += 12, 0.0)        /* Need a function to convert from packed to double
72                            precision.   Actually, it's easier to print a
73                            packed number than a double anyway, so maybe
74                            there should be a special case to handle this... */
75 \f
76 /* Print the m68k instruction at address MEMADDR in debugged memory,
77    on STREAM.  Returns length of the instruction, in bytes.  */
78
79 int
80 print_insn_m68k(addr, buffer, stream)
81      bfd_vma addr;
82 unsigned    char *buffer;
83      FILE *stream;
84 {
85   register unsigned int i;
86   register unsigned char *p;
87   register char *d;
88   register unsigned int bestmask;
89   int best;
90
91
92
93   bestmask = 0;
94   best = -1;
95   for (i = 0; i < NOPCODES; i++)
96     {
97       register unsigned int opcode = m68k_opcodes[i].opcode;
98       register unsigned int match = m68k_opcodes[i].match;
99       if (((0xff & buffer[0] & (match >> 24)) == (0xff & (opcode >> 24)))
100           && ((0xff & buffer[1] & (match >> 16)) == (0xff & (opcode >> 16)))
101           && ((0xff & buffer[2] & (match >> 8)) == (0xff & (opcode >> 8)))
102           && ((0xff & buffer[3] & match) == (0xff & opcode)))
103         {
104           /* Don't use for printout the variants of divul and divsl
105              that have the same register number in two places.
106              The more general variants will match instead.  */
107           for (d = m68k_opcodes[i].args; *d; d += 2)
108             if (d[1] == 'D')
109               break;
110
111           /* Don't use for printout the variants of most floating
112              point coprocessor instructions which use the same
113              register number in two places, as above. */
114           if (*d == 0)
115             for (d = m68k_opcodes[i].args; *d; d += 2)
116               if (d[1] == 't')
117                 break;
118
119           if (*d == 0 && match > bestmask)
120             {
121               best = i;
122               bestmask = match;
123             }
124         }
125     }
126
127   /* Handle undefined instructions.  */
128   if (best < 0)
129     {
130       fprintf (stream, "0%o", (unsigned) (buffer[0] << 8) + buffer[1]);
131       return 2;
132     }
133
134   fprintf (stream, "%s", m68k_opcodes[best].name);
135
136   /* Point at first word of argument data,
137      and at descriptor for first argument.  */
138   p = buffer + 2;
139   
140   /* Why do this this way? -MelloN */
141   for (d = m68k_opcodes[best].args; *d; d += 2)
142     {
143       if (d[0] == '#')
144         {
145           if (d[1] == 'l' && p - buffer < 6)
146             p = buffer + 6;
147           else if (p - buffer < 4 && d[1] != 'C' && d[1] != '8' )
148             p = buffer + 4;
149         }
150       if (d[1] >= '1' && d[1] <= '3' && p - buffer < 4)
151         p = buffer + 4;
152       if (d[1] >= '4' && d[1] <= '6' && p - buffer < 6)
153         p = buffer + 6;
154       if ((d[0] == 'L' || d[0] == 'l') && d[1] == 'w' && p - buffer < 4)
155         p = buffer + 4;
156     }
157
158   d = m68k_opcodes[best].args;
159
160   if (*d)
161     fputs (" ", stream);
162
163   while (*d)
164     {
165       p = print_insn_arg (d, buffer, p, addr + p - buffer, stream);
166       d += 2;
167       if (*d && *(d - 2) != 'I' && *d != 'k')
168         fputs (",", stream);
169     }
170   return p - buffer;
171 }
172
173 static unsigned char *
174 print_insn_arg (d, buffer, p, addr, stream)
175      char *d;
176      unsigned char *buffer;
177      register unsigned char *p;
178  bfd_vma addr;          /* PC for this arg to be relative to */
179      FILE *stream;
180 {
181   register int val = 0;
182   register int place = d[1];
183   int regno;
184   register char *regname;
185   register unsigned char *p1;
186   register double flval = 0;
187   int flt_p;
188
189   switch (*d)
190     {
191     case 'C':
192       fprintf (stream, "ccr");
193       break;
194
195     case 'S':
196       fprintf (stream, "sr");
197       break;
198
199     case 'U':
200       fprintf (stream, "usp");
201       break;
202
203     case 'J':
204       {
205         static struct { char *name; int value; } names[]
206           = {{"sfc", 0x000}, {"dfc", 0x001}, {"cacr", 0x002},
207              {"usp", 0x800}, {"vbr", 0x801}, {"caar", 0x802},
208              {"msp", 0x803}, {"isp", 0x804}};
209
210         val = fetch_arg (buffer, place, 12);
211         for (regno = sizeof names / sizeof names[0] - 1; regno >= 0; regno--)
212           if (names[regno].value == val)
213             {
214               fprintf (stream, names[regno].name);
215               break;
216             }
217         if (regno < 0)
218           fprintf (stream, "%d", val);
219       }
220       break;
221
222     case 'Q':
223       val = fetch_arg (buffer, place, 3);
224       if (val == 0) val = 8;
225       fprintf (stream, "#%d", val);
226       break;
227
228     case 'M':
229       val = fetch_arg (buffer, place, 8);
230       if (val & 0x80)
231         val = val - 0x100;
232       fprintf (stream, "#%d", val);
233       break;
234
235     case 'T':
236       val = fetch_arg (buffer, place, 4);
237       fprintf (stream, "#%d", val);
238       break;
239
240     case 'D':
241       fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 3)]);
242       break;
243
244     case 'A':
245       fprintf (stream, "%s",
246                         reg_names[fetch_arg (buffer, place, 3) + 010]);
247       break;
248
249     case 'R':
250       fprintf (stream, "%s", reg_names[fetch_arg (buffer, place, 4)]);
251       break;
252
253     case 'F':
254       fprintf (stream, "fp%d", fetch_arg (buffer, place, 3));
255       break;
256
257     case 'O':
258       val = fetch_arg (buffer, place, 6);
259       if (val & 0x20)
260         fprintf (stream, "%s", reg_names [val & 7]);
261       else
262         fprintf (stream, "%d", val);
263       break;
264
265     case '+':
266       fprintf (stream, "%s@+",
267                         reg_names[fetch_arg (buffer, place, 3) + 8]);
268       break;
269
270     case '-':
271       fprintf (stream, "%s@-",
272                reg_names[fetch_arg (buffer, place, 3) + 8]);
273       break;
274
275     case 'k':
276       if (place == 'k')
277         fprintf (stream, "{%s}", reg_names[fetch_arg (buffer, place, 3)]);
278       else if (place == 'C')
279         {
280           val = fetch_arg (buffer, place, 7);
281           if ( val > 63 )               /* This is a signed constant. */
282             val -= 128;
283           fprintf (stream, "{#%d}", val);
284         }
285       else
286         fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
287                *d, place);
288       break;
289
290     case '#':
291     case '^':
292       p1 = buffer + (*d == '#' ? 2 : 4);
293       if (place == 's')
294         val = fetch_arg (buffer, place, 4);
295       else if (place == 'C')
296         val = fetch_arg (buffer, place, 7);
297       else if (place == '8')
298         val = fetch_arg (buffer, place, 3);
299       else if (place == '3')
300         val = fetch_arg (buffer, place, 8);
301       else if (place == 'b')
302         val = NEXTBYTE (p1);
303       else if (place == 'w')
304         val = NEXTWORD (p1);
305       else if (place == 'l')
306         val = NEXTLONG (p1);
307       else
308         fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
309                *d, place);
310       fprintf (stream, "#%d", val);
311       break;
312
313     case 'B':
314       if (place == 'b')
315         val = NEXTBYTE (p);
316       else if (place == 'B')
317         val = COERCE_SIGNED_CHAR(buffer[1]);
318       else if (place == 'w' || place == 'W')
319         val = NEXTWORD (p);
320       else if (place == 'l' || place == 'L')
321         val = NEXTLONG (p);
322       else if (place == 'g')
323         {
324           val = ((char *)buffer)[1];
325           if (val == 0)
326             val = NEXTWORD (p);
327           else if (val == -1)
328             val = NEXTLONG (p);
329         }
330       else if (place == 'c')
331         {
332           if (buffer[1] & 0x40)         /* If bit six is one, long offset */
333             val = NEXTLONG (p);
334           else
335             val = NEXTWORD (p);
336         }
337       else
338         fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
339                *d, place);
340       print_address (addr + val, stream);
341       break;
342
343     case 'd':
344       val = NEXTWORD (p);
345       fprintf (stream, "%s@(%d)",
346                         reg_names[fetch_arg (buffer, place, 3)], val);
347       break;
348
349     case 's':
350       fprintf (stream, "%s",
351                         fpcr_names[fetch_arg (buffer, place, 3)]);
352       break;
353
354     case 'I':
355       val = fetch_arg (buffer, 'd', 3);           /* Get coprocessor ID... */
356       if (val != 1)                             /* Unusual coprocessor ID? */
357         fprintf (stream, "(cpid=%d) ", val);
358       if (place == 'i')
359         p += 2;                      /* Skip coprocessor extended operands */
360       break;
361
362     case '*':
363     case '~':
364     case '%':
365     case ';':
366     case '@':
367     case '!':
368     case '$':
369     case '?':
370     case '/':
371     case '&':
372
373       if (place == 'd')
374         {
375           val = fetch_arg (buffer, 'x', 6);
376           val = ((val & 7) << 3) + ((val >> 3) & 7);
377         }
378       else
379         val = fetch_arg (buffer, 's', 6);
380
381       /* Get register number assuming address register.  */
382       regno = (val & 7) + 8;
383       regname = reg_names[regno];
384       switch (val >> 3)
385         {
386         case 0:
387           fprintf (stream, "%s", reg_names[val]);
388           break;
389
390         case 1:
391           fprintf (stream, "%s", regname);
392           break;
393
394         case 2:
395           fprintf (stream, "%s@", regname);
396           break;
397
398         case 3:
399           fprintf (stream, "%s@+", regname);
400           break;
401
402         case 4:
403           fprintf (stream, "%s@-", regname);
404           break;
405
406         case 5:
407           val = NEXTWORD (p);
408           fprintf (stream, "%s@(%d)", regname, val);
409           break;
410
411         case 6:
412           p = print_indexed (regno, p, addr, stream);
413           break;
414
415         case 7:
416           switch (val & 7)
417             {
418             case 0:
419               val = NEXTWORD (p);
420               fprintf (stream, "@#");
421               print_address (val, stream);
422               break;
423
424             case 1:
425               val = NEXTLONG (p);
426               fprintf (stream, "@#");
427               print_address (val, stream);
428               break;
429
430             case 2:
431               val = NEXTWORD (p);
432               print_address (addr + val, stream);
433               break;
434
435             case 3:
436               p = print_indexed (-1, p, addr, stream);
437               break;
438
439             case 4:
440               flt_p = 1;        /* Assume it's a float... */
441               switch( place )
442               {
443                 case 'b':
444                   val = NEXTBYTE (p);
445                   flt_p = 0;
446                   break;
447
448                 case 'w':
449                   val = NEXTWORD (p);
450                   flt_p = 0;
451                   break;
452
453                 case 'l':
454                   val = NEXTLONG (p);
455                   flt_p = 0;
456                   break;
457
458                 case 'f':
459                   flval = NEXTSINGLE(p);
460                   break;
461
462                 case 'F':
463                   flval = NEXTDOUBLE(p);
464                   break;
465
466                 case 'x':
467                   flval = NEXTEXTEND(p);
468                   break;
469
470                 case 'p':
471                   flval = NEXTPACKED(p);
472                   break;
473
474                 default:
475                   fprintf(stderr, "Invalid arg format in opcode table: \"%c%c\".",
476                        *d, place);
477               }
478               if ( flt_p )      /* Print a float? */
479                 fprintf (stream, "#%g", flval);
480               else
481                 fprintf (stream, "#%d", val);
482               break;
483
484             default:
485               fprintf (stream, "<invalid address mode 0%o>", (unsigned) val);
486             }
487         }
488       break;
489
490     case 'L':
491     case 'l':
492         if (place == 'w')
493           {
494             char doneany;
495             p1 = buffer + 2;
496             val = NEXTWORD (p1);
497             /* Move the pointer ahead if this point is farther ahead
498                than the last.  */
499             p = p1 > p ? p1 : p;
500             if (val == 0)
501               {
502                 fputs ("#0", stream);
503                 break;
504               }
505             if (*d == 'l')
506               {
507                 register int newval = 0;
508                 for (regno = 0; regno < 16; ++regno)
509                   if (val & (0x8000 >> regno))
510                     newval |= 1 << regno;
511                 val = newval;
512               }
513             val &= 0xffff;
514             doneany = 0;
515             for (regno = 0; regno < 16; ++regno)
516               if (val & (1 << regno))
517                 {
518                   int first_regno;
519                   if (doneany)
520                     fputs ("/", stream);
521                   doneany = 1;
522                   fprintf (stream, "%s", reg_names[regno]);
523                   first_regno = regno;
524                   while (val & (1 << (regno + 1)))
525                     ++regno;
526                   if (regno > first_regno)
527                     fprintf (stream, "-%s", reg_names[regno]);
528                 }
529           }
530         else if (place == '3')
531           {
532             /* `fmovem' insn.  */
533             char doneany;
534             val = fetch_arg (buffer, place, 8);
535             if (val == 0)
536               {
537                 fputs ("#0", stream);
538                 break;
539               }
540             if (*d == 'l')
541               {
542                 register int newval = 0;
543                 for (regno = 0; regno < 8; ++regno)
544                   if (val & (0x80 >> regno))
545                     newval |= 1 << regno;
546                 val = newval;
547               }
548             val &= 0xff;
549             doneany = 0;
550             for (regno = 0; regno < 8; ++regno)
551               if (val & (1 << regno))
552                 {
553                   int first_regno;
554                   if (doneany)
555                     fputs ("/", stream);
556                   doneany = 1;
557                   fprintf (stream, "fp%d", regno);
558                   first_regno = regno;
559                   while (val & (1 << (regno + 1)))
560                     ++regno;
561                   if (regno > first_regno)
562                     fprintf (stream, "-fp%d", regno);
563                 }
564           }
565         else
566           abort ();
567       break;
568
569     default:
570       fprintf(stderr, "Invalid arg format in opcode table: \"%c\".", *d);
571     }
572
573   return (unsigned char *) p;
574 }
575
576 /* Fetch BITS bits from a position in the instruction specified by CODE.
577    CODE is a "place to put an argument", or 'x' for a destination
578    that is a general address (mode and register).
579    BUFFER contains the instruction.  */
580
581 static int
582 fetch_arg (buffer, code, bits)
583      unsigned char *buffer;
584      char code;
585      int bits;
586 {
587   register int val = 0;
588   switch (code)
589     {
590     case 's':
591       val = buffer[1];
592       break;
593
594     case 'd':                   /* Destination, for register or quick.  */
595       val = (buffer[0] << 8) + buffer[1];
596       val >>= 9;
597       break;
598
599     case 'x':                   /* Destination, for general arg */
600       val = (buffer[0] << 8) + buffer[1];
601       val >>= 6;
602       break;
603
604     case 'k':
605       val = (buffer[3] >> 4);
606       break;
607
608     case 'C':
609       val = buffer[3];
610       break;
611
612     case '1':
613       val = (buffer[2] << 8) + buffer[3];
614       val >>= 12;
615       break;
616
617     case '2':
618       val = (buffer[2] << 8) + buffer[3];
619       val >>= 6;
620       break;
621
622     case '3':
623     case 'j':
624       val = (buffer[2] << 8) + buffer[3];
625       break;
626
627     case '4':
628       val = (buffer[4] << 8) + buffer[5];
629       val >>= 12;
630       break;
631
632     case '5':
633       val = (buffer[4] << 8) + buffer[5];
634       val >>= 6;
635       break;
636
637     case '6':
638       val = (buffer[4] << 8) + buffer[5];
639       break;
640
641     case '7':
642       val = (buffer[2] << 8) + buffer[3];
643       val >>= 7;
644       break;
645       
646     case '8':
647       val = (buffer[2] << 8) + buffer[3];
648       val >>= 10;
649       break;
650
651     default:
652       abort ();
653     }
654
655   switch (bits)
656     {
657     case 3:
658       return val & 7;
659     case 4:
660       return val & 017;
661     case 5:
662       return val & 037;
663     case 6:
664       return val & 077;
665     case 7:
666       return val & 0177;
667     case 8:
668       return val & 0377;
669     case 12:
670       return val & 07777;
671     default:
672       abort ();
673       return(0);
674     }
675 } /* fetch_arg() */
676
677 /* Print an indexed argument.  The base register is BASEREG (-1 for pc).
678    P points to extension word, in buffer.
679    ADDR is the nominal core address of that extension word.  */
680
681 static unsigned char *
682 print_indexed (basereg, p, addr, stream)
683      int basereg;
684      unsigned char *p;
685      FILE *stream;
686 bfd_vma addr;
687 {
688   register int word;
689   static char *scales[] = {"", "*2", "*4", "*8"};
690   register int base_disp;
691   register int outer_disp;
692   char buf[40];
693
694   word = NEXTWORD (p);
695
696   /* Generate the text for the index register.
697      Where this will be output is not yet determined.  */
698   sprintf (buf, "[%s.%c%s]",
699            reg_names[(word >> 12) & 0xf],
700            (word & 0x800) ? 'l' : 'w',
701            scales[(word >> 9) & 3]);
702
703   /* Handle the 68000 style of indexing.  */
704
705   if ((word & 0x100) == 0)
706     {
707       print_base (basereg,
708                   ((word & 0x80) ? word | 0xff00 : word & 0xff)
709                   + ((basereg == -1) ? addr : 0),
710                   stream);
711       fputs (buf, stream);
712       return p;
713     }
714
715   /* Handle the generalized kind.  */
716   /* First, compute the displacement to add to the base register.  */
717
718   if (word & 0200)
719     basereg = -2;
720   if (word & 0100)
721     buf[0] = 0;
722   base_disp = 0;
723   switch ((word >> 4) & 3)
724     {
725     case 2:
726       base_disp = NEXTWORD (p);
727       break;
728     case 3:
729       base_disp = NEXTLONG (p);
730     }
731   if (basereg == -1)
732     base_disp += addr;
733
734   /* Handle single-level case (not indirect) */
735
736   if ((word & 7) == 0)
737     {
738       print_base (basereg, base_disp, stream);
739       fputs (buf, stream);
740       return p;
741     }
742
743   /* Two level.  Compute displacement to add after indirection.  */
744
745   outer_disp = 0;
746   switch (word & 3)
747     {
748     case 2:
749       outer_disp = NEXTWORD (p);
750       break;
751     case 3:
752       outer_disp = NEXTLONG (p);
753     }
754
755   fprintf (stream, "%d(", outer_disp);
756   print_base (basereg, base_disp, stream);
757
758   /* If postindexed, print the closeparen before the index.  */
759   if (word & 4)
760     fprintf (stream, ")%s", buf);
761   /* If preindexed, print the closeparen after the index.  */
762   else
763     fprintf (stream, "%s)", buf);
764
765   return p;
766 }
767
768 /* Print a base register REGNO and displacement DISP, on STREAM.
769    REGNO = -1 for pc, -2 for none (suppressed).  */
770
771 static void
772 print_base (regno, disp, stream)
773      int regno;
774      int disp;
775      FILE *stream;
776 {
777   if (regno == -2)
778     fprintf (stream, "%d", disp);
779   else if (regno == -1)
780     fprintf (stream, "0x%x", (unsigned) disp);
781   else
782     fprintf (stream, "%d(%s)", disp, reg_names[regno]);
783 }