opcodes/ppc-dis.c

   1 /* ppc-dis.c -- Disassemble PowerPC instructions
   2    Copyright 1994 Free Software Foundation, Inc.
   3    Written by Ian Lance Taylor, Cygnus Support
   4
   5 This file is part of GDB, GAS, and the GNU binutils.
   6
   7 GDB, GAS, and the GNU binutils are free software; you can redistribute
   8 them and/or modify them under the terms of the GNU General Public
   9 License as published by the Free Software Foundation; either version
  10 2, or (at your option) any later version.
  11
  12 GDB, GAS, and the GNU binutils are distributed in the hope that they
  13 will be useful, but WITHOUT ANY WARRANTY; without even the implied
  14 warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See
  15 the GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with this file; see the file COPYING.  If not, write to the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
  20
  21 #include <stdio.h>
  22 #include "sysdep.h"
  23 #include "dis-asm.h"
  24 #include "opcode/ppc.h"
  25
  26 /* This file provides several disassembler functions, all of which use
  27    the disassembler interface defined in dis-asm.h.  Several functions
  28    are provided because this file handles disassembly for the PowerPC
  29    in both big and little endian mode and also for the POWER (RS/6000)
  30    chip.  */
  31
  32 static int print_insn_powerpc PARAMS ((bfd_vma, struct disassemble_info *,
  33                                        int bigendian, int dialect));
  34
  35 /* Print a big endian PowerPC instruction.  For convenience, also
  36    disassemble instructions supported by the Motorola PowerPC 601.  */
  37
  38 int
  39 print_insn_big_powerpc (memaddr, info)
  40      bfd_vma memaddr;
  41      struct disassemble_info *info;
  42 {
  43   return print_insn_powerpc (memaddr, info, 1,
  44                              PPC_OPCODE_PPC | PPC_OPCODE_601);
  45 }
  46
  47 /* Print a little endian PowerPC instruction.  For convenience, also
  48    disassemble instructions supported by the Motorola PowerPC 601.  */
  49
  50 int
  51 print_insn_little_powerpc (memaddr, info)
  52      bfd_vma memaddr;
  53      struct disassemble_info *info;
  54 {
  55   return print_insn_powerpc (memaddr, info, 0,
  56                              PPC_OPCODE_PPC | PPC_OPCODE_601);
  57 }
  58
  59 /* Print a POWER (RS/6000) instruction.  */
  60
  61 int
  62 print_insn_rs6000 (memaddr, info)
  63      bfd_vma memaddr;
  64      struct disassemble_info *info;
  65 {
  66   return print_insn_powerpc (memaddr, info, 1, PPC_OPCODE_POWER);
  67 }
  68
  69 /* Print a PowerPC or POWER instruction.  */
  70
  71 static int
  72 print_insn_powerpc (memaddr, info, bigendian, dialect)
  73      bfd_vma memaddr;
  74      struct disassemble_info *info;
  75      int bigendian;
  76      int dialect;
  77 {
  78   bfd_byte buffer[4];
  79   int status;
  80   unsigned long insn;
  81   const struct powerpc_opcode *opcode;
  82   const struct powerpc_opcode *opcode_end;
  83   unsigned long op;
  84
  85   status = (*info->read_memory_func) (memaddr, buffer, 4, info);
  86   if (status != 0)
  87     {
  88       (*info->memory_error_func) (status, memaddr, info);
  89       return -1;
  90     }
  91
  92   if (bigendian)
  93     insn = bfd_getb32 (buffer);
  94   else
  95     insn = bfd_getl32 (buffer);
  96
  97   /* Get the major opcode of the instruction.  */
  98   op = PPC_OP (insn);
  99
 100   /* Find the first match in the opcode table.  We could speed this up
 101      a bit by doing a binary search on the major opcode.  */
 102   opcode_end = powerpc_opcodes + powerpc_num_opcodes;
 103   for (opcode = powerpc_opcodes; opcode < opcode_end; opcode++)
 104     {
 105       unsigned long table_op;
 106       const unsigned char *opindex;
 107       const struct powerpc_operand *operand;
 108       int invalid;
 109       int need_comma;
 110       int need_paren;
 111
 112       table_op = PPC_OP (opcode->opcode);
 113       if (op < table_op)
 114         break;
 115       if (op > table_op)
 116         continue;
 117
 118       if ((insn & opcode->mask) != opcode->opcode
 119           || (opcode->flags & dialect) == 0)
 120         continue;
 121
 122       /* Make two passes over the operands.  First see if any of them
 123          have extraction functions, and, if they do, make sure the
 124          instruction is valid.  */
 125       invalid = 0;
 126       for (opindex = opcode->operands; *opindex != 0; opindex++)
 127         {
 128           operand = powerpc_operands + *opindex;
 129           if (operand->extract)
 130             (*operand->extract) (insn, &invalid);
 131         }
 132       if (invalid)
 133         continue;
 134
 135       /* The instruction is valid.  */
 136       (*info->fprintf_func) (info->stream, "%s", opcode->name);
 137       if (opcode->operands[0] != 0)
 138         (*info->fprintf_func) (info->stream, "\t");
 139
 140       /* Now extract and print the operands.  */
 141       need_comma = 0;
 142       need_paren = 0;
 143       for (opindex = opcode->operands; *opindex != 0; opindex++)
 144         {
 145           long value;
 146
 147           operand = powerpc_operands + *opindex;
 148
 149           /* Operands that are marked FAKE are simply ignored.  We
 150              already made sure that the extract function considered
 151              the instruction to be valid.  */
 152           if ((operand->flags & PPC_OPERAND_FAKE) != 0)
 153             continue;
 154
 155           /* Extract the value from the instruction.  */
 156           if (operand->extract)
 157             value = (*operand->extract) (insn, (int *) NULL);
 158           else
 159             {
 160               value = (insn >> operand->shift) & ((1 << operand->bits) - 1);
 161               if ((operand->flags & PPC_OPERAND_SIGNED) != 0
 162                   && (value & (1 << (operand->bits - 1))) != 0)
 163                 value -= 1 << operand->bits;
 164             }
 165
 166           /* If the operand is optional, and the value is zero, don't
 167              print anything.  */
 168           if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
 169               && (operand->flags & PPC_OPERAND_NEXT) == 0
 170               && value == 0)
 171             continue;
 172
 173           if (need_comma)
 174             {
 175               (*info->fprintf_func) (info->stream, ",");
 176               need_comma = 0;
 177             }
 178
 179           /* Print the operand as directed by the flags.  */
 180           if ((operand->flags & PPC_OPERAND_GPR) != 0)
 181             (*info->fprintf_func) (info->stream, "r%ld", value);
 182           else if ((operand->flags & PPC_OPERAND_FPR) != 0)
 183             (*info->fprintf_func) (info->stream, "f%ld", value);
 184           else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0)
 185             (*info->print_address_func) (memaddr + value, info);
 186           else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
 187             (*info->print_address_func) ((bfd_vma) value & 0xffffffff, info);
 188           else if ((operand->flags & PPC_OPERAND_CR) == 0
 189                    || (dialect & PPC_OPCODE_PPC) == 0)
 190             (*info->fprintf_func) (info->stream, "%ld", value);
 191           else
 192             {
 193               if (operand->bits == 3)
 194                 (*info->fprintf_func) (info->stream, "cr%d", value);
 195               else
 196                 {
 197                   static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
 198                   int cr;
 199                   int cc;
 200
 201                   cr = value >> 2;
 202                   if (cr != 0)
 203                     (*info->fprintf_func) (info->stream, "4*cr%d", cr);
 204                   cc = value & 3;
 205                   if (cc != 0)
 206                     {
 207                       if (cr != 0)
 208                         (*info->fprintf_func) (info->stream, "+");
 209                       (*info->fprintf_func) (info->stream, "%s", cbnames[cc]);
 210                     }
 211                 }
 212             }
 213
 214           if (need_paren)
 215             {
 216               (*info->fprintf_func) (info->stream, ")");
 217               need_paren = 0;
 218             }
 219
 220           if ((operand->flags & PPC_OPERAND_PARENS) == 0)
 221             need_comma = 1;
 222           else
 223             {
 224               (*info->fprintf_func) (info->stream, "(");
 225               need_paren = 1;
 226             }
 227         }
 228
 229       /* We have found and printed an instruction; return.  */
 230       return 4;
 231     }
 232
 233   /* We could not find a match.  */
 234   (*info->fprintf_func) (info->stream, ".long 0x%lx", insn);
 235
 236   return 4;
 237 }