home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Source Code 1993 July / THE_SOURCE_CODE_CD_ROM.iso / gnu / gdb-4.9 / gdb / arm-pinsn.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-05-12  |  6.7 KB  |  268 lines
  1. /* Print Acorn Risc Machine instructions for GDB, the GNU debugger.
  2.    Copyright 1986, 1989, 1991, 1992 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 <ctype.h>
  22. #include <assert.h>
  23.  
  24. #include "symtab.h"
  25. #include "opcode/arm.h"
  26.  
  27. static char *shift_names[] = {
  28.     "lsl", "lsr", "asr", "ror",
  29. };
  30.  
  31. static char *cond_names[] = {
  32.     "eq", "ne", "cs", "cc", "mi", "pl", "vs", "vc",
  33.     "hi", "ls", "ge", "lt", "gt", "le", "", "nv"
  34. };
  35.  
  36. static char float_precision[] = "sdep";
  37. static char float_rounding[] = " pmz";
  38. static float float_immed[] = { 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 0.5, 10.0 };
  39.  
  40. static void print_ldr_str_offset();
  41. static void print_ldc_stc_offset();
  42. static long immediate_value();
  43.  
  44. /* Print the ARM instruction at address MEMADDR in debugged memory,
  45.    on STREAM.  Returns length of the instruction, in bytes.  */
  46.  
  47. int
  48. print_insn (memaddr, stream)
  49.      CORE_ADDR memaddr;
  50.      FILE *stream;
  51. {
  52.     unsigned long ins;
  53.     register struct opcode *op;
  54.     register char *p;
  55.     register int i, c;
  56.     int s, e, val;
  57.  
  58.     ins = read_memory_integer(memaddr, 4);
  59.     for (i = 0, op = opcodes; i < N_OPCODES; i++, op++)
  60.     if ((ins & op->mask) == op->value) break;
  61.     assert(i != N_OPCODES);
  62.     
  63.     for (p = op->assembler; *p;) {
  64.     c = *p++;
  65.     if (c == '%') {
  66.         s = e = 0;
  67.         while (isdigit(*p))
  68.         s = s*10 + (*p++ - '0');
  69.         if (*p == '-') {
  70.         p++;
  71.         while (isdigit(*p))
  72.             e = e*10 + (*p++ - '0');
  73.         } else
  74.         e = s;
  75.         assert(s >= 0 && s <= 31 && e >= 0 && e <= 31);
  76.         val = (ins >> s) & ((1 << (e + 1 - s)) - 1);
  77.         switch (*p++) {
  78.         case '%' :
  79.         putc('%', stream);
  80.         break;
  81.         case 'd' :
  82.         fprintf(stream, "%d", val);
  83.         break;
  84.         case 'x' :
  85.         fprintf(stream, "%x", val);
  86.         break;
  87.         case 'r' :
  88.         assert(val >= 0 && val <= 15);
  89.         fprintf(stream, "%s", reg_names[val]);
  90.         break;
  91.         case 'c' :
  92.         fprintf(stream, "%s", cond_names[ins >> 28]);
  93.         break;
  94.         case '\'' :
  95.         assert(*p);
  96.         c = *p++;
  97.         if (val)
  98.             putc(c, stream);
  99.         break;
  100.         case '`' :
  101.         assert(*p);
  102.         c = *p++;
  103.         if (!val)
  104.             putc(c, stream);
  105.         break;
  106.         case '?' :
  107.         assert(*p);
  108.         c = *p++;
  109.         assert(*p);
  110.         if (val)
  111.             p++;
  112.         else
  113.             c = *p++;
  114.         putc(c, stream);
  115.         break;
  116.         case 'p' :
  117.         if (((ins >> 12) & 0xf) == 0xf)
  118.             putc('p', stream);
  119.         break;
  120.         case 'o' :
  121.         if (ins & (1<<25)) {
  122.             int immed = immediate_value(ins & 0xfff);
  123.             fprintf (stream, "#%d (0x%x)", immed, immed);
  124.         } else {
  125.             int operand2 = ins & 0xfff;
  126.             /* in operand2 :
  127.                bits 0-3 are the base register
  128.                bits 5-6 are the shift (0=lsl, 1=lsr, 2=asr, 3=ror)
  129.                if bit 4 is zero then bits 7-11 are an immediate shift count
  130.                else bit 7 must be zero and bits 8-11 are the register
  131.                to be used as a shift count.
  132.                Note: no shift at all is encoded as "reg lsl #0" */
  133.             fprintf (stream, "%s", reg_names[operand2 & 0xf]);
  134.             if (operand2 & 0xff0) {
  135.             /* ror #0 is really rrx (rotate right extend) */
  136.             if ((operand2 & 0xff0) == 0x060)
  137.                 fprintf (stream, ", rrx");
  138.             else {
  139.                 fprintf (stream, ", %s ",
  140.                      shift_names[(operand2 >> 5) & 3]);
  141.                 if (operand2 & (1<<4)) /* register shift */
  142.                 fprintf (stream, "%s",
  143.                      reg_names[operand2 >> 8]);
  144.                 else    /* immediate shift */
  145.                 fprintf (stream, "#%d",
  146.                      operand2 >> 7);
  147.             }
  148.             }
  149.         }
  150.         break;
  151.         case 'a' :
  152.         fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
  153.         if (ins & (1<<24)) {
  154.             fprintf (stream, ", ");
  155.             print_ldr_str_offset (ins, stream);
  156.             putc (']', stream);
  157.             if (ins & (1<<21)) putc('!', stream);
  158.             /* If it is a pc relative load, then it is probably
  159.                a constant so print it */
  160.             if (((ins >> 16) & 0xf) == 15 &&
  161.             (ins & (1<<25)) == 0 &&
  162.             (ins & (1<<20))) {
  163.             int addr = memaddr + 8 +
  164.                 (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1);
  165.             fprintf (stream, " (contents=");
  166.             print_address (read_memory_integer(addr, 4), stream);
  167.             fprintf (stream, ")");
  168.             }
  169.         } else {
  170.             fprintf (stream, "]," );
  171.             print_ldr_str_offset (ins, stream);
  172.         }
  173.         break;
  174.         case 'b' :
  175.         print_address (memaddr + 8 + (((int)ins << 8) >> 6), stream);
  176.         break;
  177.         case 'A' :
  178.         fprintf (stream, "[%s", reg_names[(ins >> 16) & 0xf]);
  179.         if (ins & (1<<24)) {
  180.             fprintf (stream, ", ");
  181.             print_ldc_stc_offset (ins, stream);
  182.             putc(']', stream);
  183.             if (ins & (1<<21))
  184.             putc('!', stream);
  185.         } else {
  186.             fprintf (stream, "], ");
  187.             print_ldc_stc_offset (ins, stream);
  188.         }
  189.         break;
  190.         case 'm' :
  191.         {
  192.             int regnum, first = 1;
  193.             putc('{', stream);
  194.             for (regnum = 0; regnum < 16; regnum++)
  195.             if (ins & (1<<regnum)) {
  196.                 if (!first)
  197.                 putc (',', stream);
  198.                 first = 0;
  199.                 fprintf (stream, "%s", reg_names[regnum]);
  200.             }
  201.             putc('}', stream);
  202.         }
  203.         break;
  204.         case 'P' :
  205.         val = ((ins >> 18) & 2) | ((ins >> 7) & 1);
  206.         putc(float_precision[val], stream);
  207.         break;
  208.         case 'Q' :
  209.         val = ((ins >> 21) & 2) | ((ins >> 15) & 1);
  210.         putc(float_precision[val], stream);
  211.         break;
  212.         case 'R' :
  213.         val = ((ins >> 5) & 3);
  214.         if (val) putc(float_rounding[val], stream);
  215.         break;
  216.         case 'f' :
  217.         assert(val >= 0 && val <= 15);
  218.         if (val > 7)
  219.             fprintf (stream, "#%3.1f", float_immed[val - 8]);
  220.         else
  221.             fprintf (stream, "f%d", val);
  222.         break;
  223.         default:
  224.         abort();
  225.         }
  226.     } else
  227.         putc(c, stream);
  228.     }
  229.     return 4;
  230. }
  231.  
  232. static long
  233. immediate_value(operand)
  234. int operand;
  235. {
  236.     int val = operand & 0xff;
  237.     int shift = 2*(operand >> 8);
  238.     /* immediate value is (val ror shift) */
  239.     return (val >> shift) | (val << (32 - shift));
  240. }
  241.  
  242. static void
  243. print_ldr_str_offset(ins, stream)
  244. unsigned long ins;
  245. FILE *stream;
  246. {
  247.     if ((ins & (1<<25)) == 0)
  248.     fprintf (stream, "#%d",
  249.          (ins & 0xfff) * ((ins & (1<<23)) ? 1 : -1));
  250.     else {
  251.     fprintf (stream, "%s%s", reg_names[ins & 0xf],
  252.          (ins & (1<<23)) ? "" : "-");
  253.     if (ins & 0xff0)
  254.         fprintf (stream, ", %s #%d",
  255.              shift_names[(ins >> 5) & 3],
  256.              (ins >> 7) & 0x1f);
  257.     }
  258. }
  259.  
  260. static void
  261. print_ldc_stc_offset(ins, stream)
  262. unsigned long ins;
  263. FILE *stream;
  264. {
  265.     fprintf (stream, "#%d",
  266.          4 * (ins & 0xff) * ((ins & (1<<23)) ? 1 : -1));
  267. }
  268.