src/vm/jit/powerpc/ppc-dis.c

   1 /* ppc-dis.c -- Disassemble PowerPC instructions
   2    Copyright 1994, 1995, 2000, 2001, 2002 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
  22 typedef unsigned char u1;
  23 typedef unsigned int u4;
  24 typedef signed int s4;
  25
  26 #include <stdio.h>
  27 #include "dis-asm.h"
  28 #include "ppc.h"
  29
  30 #include <string.h>
  31
  32 unsigned long bfd_getb32(void *);
  33 unsigned long bfd_getl32(void *);
  34
  35 /* This file provides several disassembler functions, all of which use
  36    the disassembler interface defined in dis-asm.h.  Several functions
  37    are provided because this file handles disassembly for the PowerPC
  38    in both big and little endian mode and also for the POWER (RS/6000)
  39    chip.  */
  40
  41 static int print_insn_powerpc PARAMS ((bfd_vma, struct disassemble_info *,
  42                                        int bigendian, int dialect));
  43
  44 static int powerpc_dialect PARAMS ((struct disassemble_info *));
  45
  46 /* Determine which set of machines to disassemble for.  PPC403/601 or
  47    BookE.  For convenience, also disassemble instructions supported
  48    by the AltiVec vector unit.  */
  49
  50 int
  51 powerpc_dialect(info)
  52      struct disassemble_info *info;
  53 {
  54   int dialect = PPC_OPCODE_PPC | PPC_OPCODE_ALTIVEC;
  55
  56 #if 0
  57   if (BFD_DEFAULT_TARGET_SIZE == 64)
  58     dialect |= PPC_OPCODE_64;
  59 #endif
  60
  61   if (info->disassembler_options
  62       && (strcmp (info->disassembler_options, "booke") == 0
  63           || strcmp (info->disassembler_options, "booke32") == 0
  64           || strcmp (info->disassembler_options, "booke64") == 0))
  65     dialect |= PPC_OPCODE_BOOKE | PPC_OPCODE_BOOKE64;
  66   else
  67     if ((0)
  68         || (info->disassembler_options
  69         && (   strcmp (info->disassembler_options, "e500") == 0
  70             || strcmp (info->disassembler_options, "e500x2") == 0)))
  71       {
  72         dialect |= PPC_OPCODE_BOOKE
  73           | PPC_OPCODE_SPE | PPC_OPCODE_ISEL
  74           | PPC_OPCODE_EFS | PPC_OPCODE_BRLOCK
  75           | PPC_OPCODE_PMR | PPC_OPCODE_CACHELCK
  76           | PPC_OPCODE_RFMCI;
  77         /* efs* and AltiVec conflict.  */
  78         dialect &= ~PPC_OPCODE_ALTIVEC;
  79       }
  80   else
  81     if (info->disassembler_options
  82         && (strcmp (info->disassembler_options, "efs") == 0))
  83       {
  84         dialect |= PPC_OPCODE_EFS;
  85         /* efs* and AltiVec conflict.  */
  86         dialect &= ~PPC_OPCODE_ALTIVEC;
  87       }
  88   else
  89     dialect |= PPC_OPCODE_403 | PPC_OPCODE_601 | PPC_OPCODE_COMMON;
  90
  91   if (info->disassembler_options
  92       && strcmp (info->disassembler_options, "power4") == 0)
  93     dialect |= PPC_OPCODE_POWER4;
  94
  95   if (info->disassembler_options)
  96     {
  97       if (strstr (info->disassembler_options, "32") != NULL)
  98         dialect &= ~PPC_OPCODE_64;
  99       else if (strstr (info->disassembler_options, "64") != NULL)
 100         dialect |= PPC_OPCODE_64;
 101     }
 102
 103   return dialect;
 104 }
 105
 106 /* Print a big endian PowerPC instruction.  */
 107
 108 int
 109 print_insn_big_powerpc (memaddr, info)
 110      bfd_vma memaddr;
 111      struct disassemble_info *info;
 112 {
 113   return print_insn_powerpc (memaddr, info, 1, powerpc_dialect(info));
 114 }
 115
 116 /* Print a little endian PowerPC instruction.  */
 117
 118 int
 119 print_insn_little_powerpc (memaddr, info)
 120      bfd_vma memaddr;
 121      struct disassemble_info *info;
 122 {
 123   return print_insn_powerpc (memaddr, info, 0, powerpc_dialect(info));
 124 }
 125
 126 /* Print a POWER (RS/6000) instruction.  */
 127
 128 int
 129 print_insn_rs6000 (memaddr, info)
 130      bfd_vma memaddr;
 131      struct disassemble_info *info;
 132 {
 133   return print_insn_powerpc (memaddr, info, 1, PPC_OPCODE_POWER);
 134 }
 135
 136 /* Print a PowerPC or POWER instruction.  */
 137
 138 static int
 139 print_insn_powerpc (memaddr, info, bigendian, dialect)
 140      bfd_vma memaddr;
 141      struct disassemble_info *info;
 142      int bigendian;
 143      int dialect;
 144 {
 145   bfd_byte buffer[4];
 146   int status;
 147   unsigned long insn;
 148   const struct powerpc_opcode *opcode;
 149   const struct powerpc_opcode *opcode_end;
 150   unsigned long op;
 151
 152   status = (*info->read_memory_func) (memaddr, buffer, 4, info);
 153   if (status != 0)
 154     {
 155       (*info->memory_error_func) (status, memaddr, info);
 156       return -1;
 157     }
 158
 159   if (bigendian)
 160     insn = bfd_getb32 (buffer);
 161   else
 162     insn = bfd_getl32 (buffer);
 163
 164   /* Get the major opcode of the instruction.  */
 165   op = PPC_OP (insn);
 166
 167   /* Find the first match in the opcode table.  We could speed this up
 168      a bit by doing a binary search on the major opcode.  */
 169   opcode_end = powerpc_opcodes + powerpc_num_opcodes;
 170   for (opcode = powerpc_opcodes; opcode < opcode_end; opcode++)
 171     {
 172       unsigned long table_op;
 173       const unsigned char *opindex;
 174       const struct powerpc_operand *operand;
 175       int invalid;
 176       int need_comma;
 177       int need_paren;
 178
 179       table_op = PPC_OP (opcode->opcode);
 180       if (op < table_op)
 181         break;
 182       if (op > table_op)
 183         continue;
 184
 185       if ((insn & opcode->mask) != opcode->opcode
 186           || (opcode->flags & dialect) == 0)
 187         continue;
 188
 189       if ((dialect & PPC_OPCODE_EFS) && (opcode->flags & PPC_OPCODE_ALTIVEC))
 190         continue;
 191
 192       /* Make two passes over the operands.  First see if any of them
 193          have extraction functions, and, if they do, make sure the
 194          instruction is valid.  */
 195       invalid = 0;
 196       for (opindex = opcode->operands; *opindex != 0; opindex++)
 197         {
 198           operand = powerpc_operands + *opindex;
 199           if (operand->extract)
 200             (*operand->extract) (insn, dialect, &invalid);
 201         }
 202       if (invalid)
 203         continue;
 204
 205       /* The instruction is valid.  */
 206       (*info->fprintf_func) (info->stream, "%s", opcode->name);
 207       if (opcode->operands[0] != 0)
 208         (*info->fprintf_func) (info->stream, "\t");
 209
 210       /* Now extract and print the operands.  */
 211       need_comma = 0;
 212       need_paren = 0;
 213       for (opindex = opcode->operands; *opindex != 0; opindex++)
 214         {
 215           long value;
 216
 217           operand = powerpc_operands + *opindex;
 218
 219           /* Operands that are marked FAKE are simply ignored.  We
 220              already made sure that the extract function considered
 221              the instruction to be valid.  */
 222           if ((operand->flags & PPC_OPERAND_FAKE) != 0)
 223             continue;
 224
 225           /* Extract the value from the instruction.  */
 226           if (operand->extract)
 227             value = (*operand->extract) (insn, dialect, (int *) NULL);
 228           else
 229             {
 230               value = (insn >> operand->shift) & ((1 << operand->bits) - 1);
 231               if ((operand->flags & PPC_OPERAND_SIGNED) != 0
 232                   && (value & (1 << (operand->bits - 1))) != 0)
 233                 value -= 1 << operand->bits;
 234             }
 235
 236           /* If the operand is optional, and the value is zero, don't
 237              print anything.  */
 238           if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
 239               && (operand->flags & PPC_OPERAND_NEXT) == 0
 240               && value == 0)
 241             continue;
 242
 243           if (need_comma)
 244             {
 245               (*info->fprintf_func) (info->stream, ",");
 246               need_comma = 0;
 247             }
 248
 249           /* Print the operand as directed by the flags.  */
 250           if ((operand->flags & PPC_OPERAND_GPR) != 0)
 251             (*info->fprintf_func) (info->stream, "r%ld", value);
 252           else if ((operand->flags & PPC_OPERAND_FPR) != 0)
 253             (*info->fprintf_func) (info->stream, "f%ld", value);
 254           else if ((operand->flags & PPC_OPERAND_VR) != 0)
 255             (*info->fprintf_func) (info->stream, "v%ld", value);
 256           else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0)
 257             (*info->print_address_func) (memaddr + value, info);
 258           else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
 259             (*info->print_address_func) ((bfd_vma) value & 0xffffffff, info);
 260           else if ((operand->flags & PPC_OPERAND_CR) == 0
 261                    || (dialect & PPC_OPCODE_PPC) == 0)
 262             (*info->fprintf_func) (info->stream, "%ld", value);
 263           else
 264             {
 265               if (operand->bits == 3)
 266                 (*info->fprintf_func) (info->stream, "cr%d", value);
 267               else
 268                 {
 269                   static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
 270                   int cr;
 271                   int cc;
 272
 273                   cr = value >> 2;
 274                   if (cr != 0)
 275                     (*info->fprintf_func) (info->stream, "4*cr%d", cr);
 276                   cc = value & 3;
 277                   if (cc != 0)
 278                     {
 279                       if (cr != 0)
 280                         (*info->fprintf_func) (info->stream, "+");
 281                       (*info->fprintf_func) (info->stream, "%s", cbnames[cc]);
 282                     }
 283                 }
 284             }
 285
 286           if (need_paren)
 287             {
 288               (*info->fprintf_func) (info->stream, ")");
 289               need_paren = 0;
 290             }
 291
 292           if ((operand->flags & PPC_OPERAND_PARENS) == 0)
 293             need_comma = 1;
 294           else
 295             {
 296               (*info->fprintf_func) (info->stream, "(");
 297               need_paren = 1;
 298             }
 299         }
 300
 301       /* We have found and printed an instruction; return.  */
 302       return 4;
 303     }
 304
 305   /* We could not find a match.  */
 306   (*info->fprintf_func) (info->stream, ".long 0x%lx", insn);
 307
 308   return 4;
 309 }