gdb/vax-pinsn.c

   1 /* Print VAX instructions for GDB, the GNU debugger.
   2    Copyright 1986, 1989, 1991 Free Software Foundation, Inc.
   3
   4 This file is part of GDB.
   5
   6 This program is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2 of the License, or
   9 (at your option) any later version.
  10
  11 This program is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with this program; if not, write to the Free Software
  18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19
  20 #include "defs.h"
  21 #include "symtab.h"
  22 #include "opcode/vax.h"
  23
  24 /* Vax instructions are never longer than this.  */
  25 #define MAXLEN 62
  26
  27 /* Number of elements in the opcode table.  */
  28 #define NOPCODES (sizeof votstrs / sizeof votstrs[0])
  29
  30 extern char *reg_names[];
  31
  32 static unsigned char *print_insn_arg ();
  33 \f
  34 /* Print the vax instruction at address MEMADDR in debugged memory,
  35    on STREAM.  Returns length of the instruction, in bytes.  */
  36
  37 int
  38 print_insn (memaddr, stream)
  39      CORE_ADDR memaddr;
  40      FILE *stream;
  41 {
  42   unsigned char buffer[MAXLEN];
  43   register int i;
  44   register unsigned char *p;
  45   register char *d;
  46
  47   read_memory (memaddr, buffer, MAXLEN);
  48
  49   for (i = 0; i < NOPCODES; i++)
  50     if (votstrs[i].detail.code == buffer[0]
  51         || votstrs[i].detail.code == *(unsigned short *)buffer)
  52       break;
  53
  54   /* Handle undefined instructions.  */
  55   if (i == NOPCODES)
  56     {
  57       fprintf (stream, "0%o", buffer[0]);
  58       return 1;
  59     }
  60
  61   fprintf (stream, "%s", votstrs[i].name);
  62
  63   /* Point at first byte of argument data,
  64      and at descriptor for first argument.  */
  65   p = buffer + 1 + (votstrs[i].detail.code >= 0x100);
  66   d = votstrs[i].detail.args;
  67
  68   if (*d)
  69     fputc (' ', stream);
  70
  71   while (*d)
  72     {
  73       p = print_insn_arg (d, p, memaddr + (p - buffer), stream);
  74       d += 2;
  75       if (*d)
  76         fprintf (stream, ",");
  77     }
  78   return p - buffer;
  79 }
  80
  81 static unsigned char *
  82 print_insn_arg (d, p, addr, stream)
  83      char *d;
  84      register char *p;
  85      CORE_ADDR addr;
  86      FILE *stream;
  87 {
  88   register int regnum = *p & 0xf;
  89   float floatlitbuf;
  90
  91   if (*d == 'b')
  92     {
  93       if (d[1] == 'b')
  94         fprintf (stream, "0x%x", addr + *p++ + 1);
  95       else
  96         {
  97           fprintf (stream, "0x%x", addr + *(short *)p + 2);
  98           p += 2;
  99         }
 100     }
 101   else
 102     switch ((*p++ >> 4) & 0xf)
 103       {
 104       case 0:
 105       case 1:
 106       case 2:
 107       case 3:                   /* Literal mode */
 108         if (d[1] == 'd' || d[1] == 'f' || d[1] == 'g' || d[1] == 'h')
 109           {
 110             *(int *)&floatlitbuf = 0x4000 + ((p[-1] & 0x3f) << 4);
 111             fprintf (stream, "$%f", floatlitbuf);
 112           }
 113         else
 114           fprintf (stream, "$%d", p[-1] & 0x3f);
 115         break;
 116
 117       case 4:                   /* Indexed */
 118         p = (char *) print_insn_arg (d, p, addr + 1, stream);
 119         fprintf (stream, "[%s]", reg_names[regnum]);
 120         break;
 121
 122       case 5:                   /* Register */
 123         fprintf (stream, reg_names[regnum]);
 124         break;
 125
 126       case 7:                   /* Autodecrement */
 127         fputc ('-', stream);
 128       case 6:                   /* Register deferred */
 129         fprintf (stream, "(%s)", reg_names[regnum]);
 130         break;
 131
 132       case 9:                   /* Autoincrement deferred */
 133         fputc ('@', stream);
 134         if (regnum == PC_REGNUM)
 135           {
 136             fputc ('#', stream);
 137             print_address (*(long *)p, stream);
 138             p += 4;
 139             break;
 140           }
 141       case 8:                   /* Autoincrement */
 142         if (regnum == PC_REGNUM)
 143           {
 144             fputc ('#', stream);
 145             switch (d[1])
 146               {
 147               case 'b':
 148                 fprintf (stream, "%d", *p++);
 149                 break;
 150
 151               case 'w':
 152                 fprintf (stream, "%d", *(short *)p);
 153                 p += 2;
 154                 break;
 155
 156               case 'l':
 157                 fprintf (stream, "%d", *(long *)p);
 158                 p += 4;
 159                 break;
 160
 161               case 'q':
 162                 fprintf (stream, "0x%x%08x", ((long *)p)[1], ((long *)p)[0]);
 163                 p += 8;
 164                 break;
 165
 166               case 'o':
 167                 fprintf (stream, "0x%x%08x%08x%08x",
 168                          ((long *)p)[3], ((long *)p)[2],
 169                          ((long *)p)[1], ((long *)p)[0]);
 170                 p += 16;
 171                 break;
 172
 173               case 'f':
 174                 if (INVALID_FLOAT (p, 4))
 175                   fprintf (stream, "<<invalid float 0x%x>>", *(int *) p);
 176                 else
 177                   fprintf (stream, "%f", *(float *) p);
 178                 p += 4;
 179                 break;
 180
 181               case 'd':
 182                 if (INVALID_FLOAT (p, 8))
 183                   fprintf (stream, "<<invalid float 0x%x%08x>>",
 184                            ((long *)p)[1], ((long *)p)[0]);
 185                 else
 186                   fprintf (stream, "%f", *(double *) p);
 187                 p += 8;
 188                 break;
 189
 190               case 'g':
 191                 fprintf (stream, "g-float");
 192                 p += 8;
 193                 break;
 194
 195               case 'h':
 196                 fprintf (stream, "h-float");
 197                 p += 16;
 198                 break;
 199
 200               }
 201           }
 202         else
 203           fprintf (stream, "(%s)+", reg_names[regnum]);
 204         break;
 205
 206       case 11:                  /* Byte displacement deferred */
 207         fputc ('@', stream);
 208       case 10:                  /* Byte displacement */
 209         if (regnum == PC_REGNUM)
 210           print_address (addr + *p + 2, stream);
 211         else
 212           fprintf (stream, "%d(%s)", *p, reg_names[regnum]);
 213         p += 1;
 214         break;
 215
 216       case 13:                  /* Word displacement deferred */
 217         fputc ('@', stream);
 218       case 12:                  /* Word displacement */
 219         if (regnum == PC_REGNUM)
 220           print_address (addr + *(short *)p + 3, stream);
 221         else
 222           fprintf (stream, "%d(%s)", *(short *)p, reg_names[regnum]);
 223         p += 2;
 224         break;
 225
 226       case 15:                  /* Long displacement deferred */
 227         fputc ('@', stream);
 228       case 14:                  /* Long displacement */
 229         if (regnum == PC_REGNUM)
 230           print_address (addr + *(long *)p + 5, stream);
 231         else
 232           fprintf (stream, "%d(%s)", *(long *)p, reg_names[regnum]);
 233         p += 4;
 234       }
 235
 236   return (unsigned char *) p;
 237 }