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, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  20
  21 #include <stdio.h>
  22 #include "ansidecl.h"
  23 #include "sysdep.h"
  24 #include "dis-asm.h"
  25 #include "opcode/ppc.h"
  26
  27 /* This file provides several disassembler functions, all of which use
  28    the disassembler interface defined in dis-asm.h.  Several functions
  29    are provided because this file handles disassembly for the PowerPC
  30    in both big and little endian mode and also for the POWER (RS/6000)
  31    chip.  */
  32
  33 static int print_insn_powerpc PARAMS ((bfd_vma, struct disassemble_info *,
  34                                        int bigendian, int dialect));
  35
  36 /* Print a big endian PowerPC instruction.  */
  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, PPC_OPCODE_PPC);
  44 }
  45
  46 /* Print a little endian PowerPC instruction.  */
  47
  48 int
  49 print_insn_little_powerpc (memaddr, info)
  50      bfd_vma memaddr;
  51      struct disassemble_info *info;
  52 {
  53   return print_insn_powerpc (memaddr, info, 0, PPC_OPCODE_PPC);
  54 }
  55
  56 /* Print a POWER (RS/6000) instruction.  */
  57
  58 int
  59 print_insn_rs6000 (memaddr, info)
  60      bfd_vma memaddr;
  61      struct disassemble_info *info;
  62 {
  63   return print_insn_powerpc (memaddr, info, 1, PPC_OPCODE_POWER);
  64 }
  65
  66 /* Print a PowerPC or POWER instruction.  */
  67
  68 static int
  69 print_insn_powerpc (memaddr, info, bigendian, dialect)
  70      bfd_vma memaddr;
  71      struct disassemble_info *info;
  72      int bigendian;
  73      int dialect;
  74 {
  75   bfd_byte buffer[4];
  76   int status;
  77   unsigned long insn;
  78   const struct powerpc_opcode *opcode;
  79   const struct powerpc_opcode *opcode_end;
  80   unsigned long op;
  81
  82   status = (*info->read_memory_func) (memaddr, buffer, 4, info);
  83   if (status != 0)
  84     {
  85       (*info->memory_error_func) (status, memaddr, info);
  86       return -1;
  87     }
  88
  89   if (bigendian)
  90     insn = bfd_getb32 (buffer);
  91   else
  92     insn = bfd_getl32 (buffer);
  93
  94   /* Get the major opcode of the instruction.  */
  95   op = PPC_OP (insn);
  96
  97   /* Find the first match in the opcode table.  We could speed this up
  98      a bit by doing a binary search on the major opcode.  */
  99   opcode_end = powerpc_opcodes + powerpc_num_opcodes;
 100   for (opcode = powerpc_opcodes; opcode < opcode_end; opcode++)
 101     {
 102       unsigned long table_op;
 103       const unsigned char *opindex;
 104       const struct powerpc_operand *operand;
 105       int invalid;
 106       int need_comma;
 107       int need_paren;
 108
 109       table_op = PPC_OP (opcode->opcode);
 110       if (op < table_op)
 111         break;
 112       if (op > table_op)
 113         continue;
 114
 115       if ((insn & opcode->mask) != opcode->opcode
 116           || (opcode->flags & dialect) == 0)
 117         continue;
 118
 119       /* Make two passes over the operands.  First see if any of them
 120          have extraction functions, and, if they do, make sure the
 121          instruction is valid.  */
 122       invalid = 0;
 123       for (opindex = opcode->operands; *opindex != 0; opindex++)
 124         {
 125           operand = powerpc_operands + *opindex;
 126           if (operand->extract)
 127             (*operand->extract) (insn, &invalid);
 128         }
 129       if (invalid)
 130         continue;
 131
 132       /* The instruction is valid.  */
 133       (*info->fprintf_func) (info->stream, "%s", opcode->name);
 134       if (opcode->operands[0] != 0)
 135         (*info->fprintf_func) (info->stream, "\t");
 136
 137       /* Now extract and print the operands.  */
 138       need_comma = 0;
 139       need_paren = 0;
 140       for (opindex = opcode->operands; *opindex != 0; opindex++)
 141         {
 142           long value;
 143
 144           operand = powerpc_operands + *opindex;
 145
 146           /* Operands that are marked FAKE are simply ignored.  We
 147              already made sure that the extract function considered
 148              the instruction to be valid.  */
 149           if ((operand->flags & PPC_OPERAND_FAKE) != 0)
 150             continue;
 151
 152           /* Extract the value from the instruction.  */
 153           if (operand->extract)
 154             value = (*operand->extract) (insn, (int *) NULL);
 155           else
 156             {
 157               value = (insn >> operand->shift) & ((1 << operand->bits) - 1);
 158               if (operand->signedp
 159                   && (value & (1 << (operand->bits - 1))) != 0)
 160                 value -= 1 << operand->bits;
 161             }
 162
 163           /* If the operand is optional, and the value is zero, don't
 164              print anything.  */
 165           if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
 166               && (operand->flags & PPC_OPERAND_NEXT) == 0
 167               && value == 0)
 168             continue;
 169
 170           if (need_comma)
 171             {
 172               (*info->fprintf_func) (info->stream, ",");
 173               need_comma = 0;
 174             }
 175
 176           /* Print the operand as directed by the flags.  */
 177           if ((operand->flags & PPC_OPERAND_GPR) != 0)
 178             (*info->fprintf_func) (info->stream, "r%ld", value);
 179           else if ((operand->flags & PPC_OPERAND_FPR) != 0)
 180             (*info->fprintf_func) (info->stream, "f%ld", value);
 181           else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0)
 182             (*info->print_address_func) (memaddr + value, info);
 183           else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
 184             (*info->print_address_func) ((bfd_vma) value & 0xffffffff, info);
 185           else if ((operand->flags & PPC_OPERAND_CR) == 0
 186                    || (dialect & PPC_OPCODE_PPC) == 0)
 187             (*info->fprintf_func) (info->stream, "%ld", value);
 188           else
 189             {
 190               if (operand->bits == 3)
 191                 (*info->fprintf_func) (info->stream, "cr%d", value);
 192               else
 193                 {
 194                   static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
 195                   int cr;
 196                   int cc;
 197
 198                   cr = value >> 2;
 199                   if (cr != 0)
 200                     (*info->fprintf_func) (info->stream, "4*cr%d", cr);
 201                   cc = value & 3;
 202                   if (cc != 0)
 203                     {
 204                       if (cr != 0)
 205                         (*info->fprintf_func) (info->stream, "+");
 206                       (*info->fprintf_func) (info->stream, "%s", cbnames[cc]);
 207                     }
 208                 }
 209             }
 210
 211           if (need_paren)
 212             {
 213               (*info->fprintf_func) (info->stream, ")");
 214               need_paren = 0;
 215             }
 216
 217           if ((operand->flags & PPC_OPERAND_PARENS) == 0)
 218             need_comma = 1;
 219           else
 220             {
 221               (*info->fprintf_func) (info->stream, "(");
 222               need_paren = 1;
 223             }
 224         }
 225
 226       /* We have found and printed an instruction; return.  */
 227       return 4;
 228     }
 229
 230   /* We could not find a match.  */
 231   (*info->fprintf_func) (info->stream, "0x%lx", insn);
 232
 233   return 4;
 234 }