home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / gdb-4.16-base.tgz / gdb-4.16-base.tar / fsf / gdb / opcodes / alpha-dis.c < prev    next >
C/C++ Source or Header  |  1996-01-12  |  8KB  |  336 lines
  1. /* Instruction printing code for the Alpha
  2.    Copyright (C) 1993, 1995 Free Software Foundation, Inc.
  3.    Contributed by Cygnus Support.
  4.  
  5. Written by Steve Chamberlain (sac@cygnus.com)
  6.  
  7. This file is part of libopcodes.
  8.  
  9. This program is free software; you can redistribute it and/or modify it under
  10. the terms of the GNU General Public License as published by the Free
  11. Software Foundation; either version 2 of the License, or (at your option)
  12. any later version.
  13.  
  14. This program is distributed in the hope that it will be useful, but WITHOUT
  15. ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  16. FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
  17. more details.
  18.  
  19. You should have received a copy of the GNU General Public License along with
  20. This program; if not, write to the Free Software Foundation, Inc., 675
  21.  Mass Ave, Boston, MA 02111-1307, USA.
  22. */
  23.  
  24. #include "dis-asm.h"
  25. #define DEFINE_TABLE
  26. #include "alpha-opc.h"
  27.  
  28.  
  29. /* Print one instruction from PC on INFO->STREAM.
  30.    Return the size of the instruction (always 4 on alpha). */
  31.  
  32. int
  33. print_insn_alpha(pc, info)
  34.      bfd_vma pc;
  35.      struct disassemble_info *info;
  36. {
  37.   alpha_insn    *insn;
  38.   unsigned char    b[4];
  39.   void        *stream = info->stream;
  40.   fprintf_ftype    func = info->fprintf_func;
  41.   unsigned long    given;
  42.   int        status ;
  43.   int found = 0;
  44.  
  45.   status = (*info->read_memory_func) (pc, (bfd_byte *) &b[0], 4, info);
  46.   if (status != 0) {
  47.     (*info->memory_error_func) (status, pc, info);
  48.     return -1;
  49.   }
  50.   given = (b[0]) | (b[1] << 8) | (b[2] << 16) | (b[3] << 24);
  51.  
  52.   func (stream, "\t%08x\t", given);
  53.  
  54.   for (insn = alpha_insn_set;
  55.        insn->name && !found;
  56.        insn++)
  57.     {
  58.       switch (insn->type)
  59.     {
  60.     case MEMORY_FORMAT_CODE:
  61.       if ((insn->i & MEMORY_FORMAT_MASK)
  62.           ==(given & MEMORY_FORMAT_MASK))
  63.         {
  64.           func (stream, "%s\t%s, %d(%s)",
  65.             insn->name,
  66.             alpha_regs[RA(given)],
  67.             OPCODE (given) == 9 ? DISP(given) * 65536 : DISP(given),
  68.             alpha_regs[RB(given)]);
  69.           found = 1;
  70.         }
  71.       break;
  72.  
  73.  
  74.     case MEMORY_FUNCTION_FORMAT_CODE:
  75.       if ((insn->i & MEMORY_FUNCTION_FORMAT_MASK)
  76.           ==(given & MEMORY_FUNCTION_FORMAT_MASK))
  77.         {
  78.           switch (given & 0xffff)
  79.         {
  80.         case 0x8000: /* fetch */
  81.         case 0xa000: /* fetch_m */
  82.           func (stream, "%s\t(%s)", insn->name, alpha_regs[RB(given)]);
  83.           break;
  84.  
  85.         case 0xc000: /* rpcc */
  86.           func (stream, "%s\t%s", insn->name, alpha_regs[RA(given)]);
  87.           break;
  88.  
  89.         default:
  90.           func (stream, "%s", insn->name);
  91.           break;
  92.         }
  93.           found = 1;
  94.         }
  95.       break;
  96.  
  97.     case BRANCH_FORMAT_CODE:
  98.       if ((insn->i & BRANCH_FORMAT_MASK)
  99.           == (given & BRANCH_FORMAT_MASK))
  100.         {
  101.           if (RA(given) == 31)
  102.         func (stream, "%s\t ", insn->name);
  103.           else
  104.         func (stream, "%s\t%s, ", insn->name,
  105.               alpha_regs[RA(given)]);
  106.           (*info->print_address_func) (BDISP(given) * 4 + pc + 4, info);
  107.           found = 1;
  108.         }
  109.       break;
  110.  
  111.     case MEMORY_BRANCH_FORMAT_CODE:
  112.       if ((insn->i & MEMORY_BRANCH_FORMAT_MASK)
  113.           == (given & MEMORY_BRANCH_FORMAT_MASK))
  114.         {
  115.           if (given & (1<<15))
  116.         {
  117.           func (stream, "%s\t%s, (%s), %d", insn->name,
  118.             alpha_regs[RA(given)],
  119.             alpha_regs[RB(given)],
  120.             JUMP_HINT(given));
  121.         }
  122.           else
  123.         {
  124.           /* The displacement is a hint only, do not put out
  125.              a symbolic address.  */
  126.           func (stream, "%s\t%s, (%s), 0x%lx", insn->name,
  127.             alpha_regs[RA(given)],
  128.             alpha_regs[RB(given)],
  129.             JDISP(given) * 4 + pc + 4);
  130.         }
  131.           found = 1;
  132.         }
  133.       break;
  134.  
  135.     case OPERATE_FORMAT_CODE:
  136.       if ((insn->i & OPERATE_FORMAT_MASK)
  137.           == (given & OPERATE_FORMAT_MASK))
  138.         {
  139.           int opcode = OPCODE(given);
  140.           int optype = OP_OPTYPE(given);
  141.           if (OP_OPTYPE(insn->i) == optype)
  142.         {
  143.           int ra;
  144.           ra = RA(given);
  145.  
  146.           if (OP_IS_CONSTANT(given))
  147.             {
  148.               if ((opcode == 0x11) && (optype == 0x20)
  149.               && (ra == 31))      /* bis R31, lit, Ry */
  150.             {
  151.               func (stream, "mov\t0x%x, %s",
  152.                 LITERAL(given), alpha_regs[RC(given)] );
  153.             }
  154.               else
  155.             {
  156. #if GNU_ASMCODE
  157.               func (stream, "%s\t%s, 0x%x, %s", insn->name,
  158.                 alpha_regs[RA(given)],
  159.                 LITERAL(given),
  160.                 alpha_regs[RC(given)]);
  161. #else
  162.               func (stream, "%s\t%s, #%d, %s", insn->name,
  163.                 alpha_regs[RA(given)],
  164.                 LITERAL(given),
  165.                 alpha_regs[RC(given)]);
  166.             }
  167. #endif
  168.           } else {        /* not constant */
  169.             int rb, rc;
  170.             rb = RB(given); rc = RC(given);
  171.             switch ((opcode << 8) | optype)
  172.               {
  173.               case 0x1009:            /* subl */
  174.             if (ra == 31)
  175.               {
  176.                 func (stream, "negl\t%s, %s",
  177.                   alpha_regs[rb], alpha_regs[rc]);
  178.                 found = 1;
  179.               }
  180.             break;
  181.               case 0x1029:            /* subq */
  182.             if (ra == 31)
  183.               {
  184.                 func (stream, "negq\t%s, %s",
  185.                   alpha_regs[rb], alpha_regs[rc]);
  186.                 found = 1;
  187.               }
  188.             break;
  189.               case 0x1120:            /* bis */
  190.             if (ra == 31)
  191.               {
  192.                 if (ra == rb)        /* ra=R31, rb=R31 */
  193.                   {
  194.                 if (rc == 31)
  195.                   func (stream, "nop");
  196.                 else
  197.                   func (stream, "clr\t%s", alpha_regs[rc]);
  198.                   }
  199.                 else
  200.                   func (stream, "mov\t%s, %s",
  201.                     alpha_regs[rb], alpha_regs[rc]);
  202.               }
  203.             else
  204.               func (stream, "or\t%s, %s, %s",
  205.                 alpha_regs[ra], alpha_regs[rb],
  206.                 alpha_regs[rc]);
  207.             found = 1;
  208.             break;
  209.  
  210.               default:
  211.             break;
  212.  
  213.               }
  214.  
  215.             if (!found)
  216.               func (stream, "%s\t%s, %s, %s", insn->name,
  217.                 alpha_regs[ra], alpha_regs[rb], alpha_regs[rc]);
  218.           }
  219.           found = 1;
  220.         }
  221.         }
  222.  
  223.       break;
  224.  
  225.     case FLOAT_FORMAT_CODE:
  226.       if ((insn->i & FLOAT_FORMAT_MASK)
  227.           == (given & FLOAT_FORMAT_MASK))
  228.         {
  229.           int ra, rb, rc;
  230.           ra = RA(given); rb = RB(given); rc = RC(given);
  231.           switch (OP_OPTYPE(given))
  232.         {
  233.         case 0x20:        /* cpys */
  234.           if (ra == 31)
  235.             {
  236.               if (rb == 31)
  237.             {
  238.               if (rc == 31)
  239.                 func (stream, "fnop");
  240.               else
  241.                 func (stream, "fclr\tf%d", rc);
  242.             }
  243.               else
  244.             func (stream, "fabs\tf%d, f%d", rb, rc);
  245.               found = 1;
  246.             }
  247.           else if (ra == rb)
  248.             {
  249.               func (stream, "fmov\tf%d, f%d", rb, rc);
  250.               found = 1;
  251.             }
  252.           break;
  253.         case 0x21:        /* cpysn */
  254.           if (ra == rb)
  255.             {
  256.               func (stream, "fneg\tf%d, f%d", rb, rc);
  257.               found = 1;
  258.             }
  259.         default:
  260.           ;
  261.             }
  262.  
  263.           if (!found)
  264.             func (stream, "%s\tf%d, f%d, f%d", insn->name, ra, rb, rc);
  265.  
  266.           found = 1;
  267.         }
  268.  
  269.       break;
  270.     case PAL_FORMAT_CODE:
  271.       if (insn->i == given)
  272.         {
  273.           func (stream, "call_pal %s", insn->name);
  274.           found = 1;
  275.         }
  276.  
  277.       break;
  278.     case FLOAT_MEMORY_FORMAT_CODE:
  279.       if ((insn->i & MEMORY_FORMAT_MASK)
  280.           ==(given & MEMORY_FORMAT_MASK))
  281.         {
  282.           func (stream, "%s\tf%d, %d(%s)",
  283.               insn->name,
  284.               RA(given),
  285.               OPCODE (given) == 9 ? DISP(given) * 65536 : DISP(given),
  286.               alpha_regs[RB(given)]);
  287.           found = 1;
  288.         }
  289.       break;
  290.     case FLOAT_BRANCH_FORMAT_CODE:
  291.       if ((insn->i & BRANCH_FORMAT_MASK)
  292.           == (given & BRANCH_FORMAT_MASK))
  293.         {
  294.           func (stream, "%s\tf%d, ",
  295.             insn->name,
  296.             RA(given));
  297.           (*info->print_address_func) (BDISP(given) * 4 + pc + 4, info);
  298.           found = 1;
  299.         }
  300.       break;
  301.     }
  302.     }
  303.  
  304.   if (!found)
  305.     switch (OPCODE (given))
  306.       {
  307.       case 0x00:
  308.     func (stream, "call_pal 0x%x", given);
  309.     break;
  310.       case 0x19:
  311.       case 0x1b:
  312.       case 0x1d:
  313.       case 0x1e:
  314.       case 0x1f:
  315.     func (stream, "PAL%X 0x%x", OPCODE (given), given & 0x3ffffff);
  316.     break;
  317.       case 0x01:
  318.       case 0x02:
  319.       case 0x03:
  320.       case 0x04:
  321.       case 0x05:
  322.       case 0x06:
  323.       case 0x07:
  324.       case 0x0a:
  325.       case 0x0c:
  326.       case 0x0d:
  327.       case 0x0e:
  328.       case 0x14:
  329.       case 0x1c:
  330.     func (stream, "OPC%02X 0x%x", OPCODE (given), given & 0x3ffffff);
  331.     break;
  332.       }
  333.  
  334.   return 4;
  335. }
  336.