arch/powerpc/xmon/spu-dis.c

   1 /* Disassemble SPU instructions
   2
   3    Copyright 2006 Free Software Foundation, Inc.
   4
   5    This file is part of GDB, GAS, and the GNU binutils.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License along
  18    with this program; if not, write to the Free Software Foundation, Inc.,
  19    51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA.  */
  20
  21 #include <linux/string.h>
  22 #include "nonstdio.h"
  23 #include "ansidecl.h"
  24 #include "spu.h"
  25 #include "dis-asm.h"
  26
  27 /* This file provides a disassembler function which uses
  28    the disassembler interface defined in dis-asm.h.   */
  29
  30 extern const struct spu_opcode spu_opcodes[];
  31 extern const int spu_num_opcodes;
  32
  33 #define SPU_DISASM_TBL_SIZE (1 << 11)
  34 static const struct spu_opcode *spu_disassemble_table[SPU_DISASM_TBL_SIZE];
  35
  36 static void
  37 init_spu_disassemble (void)
  38 {
  39   int i;
  40
  41   /* If two instructions have the same opcode then we prefer the first
  42    * one.  In most cases it is just an alternate mnemonic. */
  43   for (i = 0; i < spu_num_opcodes; i++)
  44     {
  45       int o = spu_opcodes[i].opcode;
  46       if (o >= SPU_DISASM_TBL_SIZE)
  47         continue; /* abort (); */
  48       if (spu_disassemble_table[o] == 0)
  49         spu_disassemble_table[o] = &spu_opcodes[i];
  50     }
  51 }
  52
  53 /* Determine the instruction from the 10 least significant bits. */
  54 static const struct spu_opcode *
  55 get_index_for_opcode (unsigned int insn)
  56 {
  57   const struct spu_opcode *index;
  58   unsigned int opcode = insn >> (32-11);
  59
  60   /* Init the table.  This assumes that element 0/opcode 0 (currently
  61    * NOP) is always used */
  62   if (spu_disassemble_table[0] == 0)
  63     init_spu_disassemble ();
  64
  65   if ((index = spu_disassemble_table[opcode & 0x780]) != 0
  66       && index->insn_type == RRR)
  67     return index;
  68
  69   if ((index = spu_disassemble_table[opcode & 0x7f0]) != 0
  70       && (index->insn_type == RI18 || index->insn_type == LBT))
  71     return index;
  72
  73   if ((index = spu_disassemble_table[opcode & 0x7f8]) != 0
  74       && index->insn_type == RI10)
  75     return index;
  76
  77   if ((index = spu_disassemble_table[opcode & 0x7fc]) != 0
  78       && (index->insn_type == RI16))
  79     return index;
  80
  81   if ((index = spu_disassemble_table[opcode & 0x7fe]) != 0
  82       && (index->insn_type == RI8))
  83     return index;
  84
  85   if ((index = spu_disassemble_table[opcode & 0x7ff]) != 0)
  86     return index;
  87
  88   return NULL;
  89 }
  90
  91 /* Print a Spu instruction.  */
  92
  93 int
  94 print_insn_spu (unsigned long insn, unsigned long memaddr)
  95 {
  96   int value;
  97   int hex_value;
  98   const struct spu_opcode *index;
  99   enum spu_insns tag;
 100
 101   index = get_index_for_opcode (insn);
 102
 103   if (index == 0)
 104     {
 105       printf(".long 0x%lx", insn);
 106     }
 107   else
 108     {
 109       int i;
 110       int paren = 0;
 111       tag = (enum spu_insns)(index - spu_opcodes);
 112       printf("%s", index->mnemonic);
 113       if (tag == M_BI || tag == M_BISL || tag == M_IRET || tag == M_BISLED
 114           || tag == M_BIHNZ || tag == M_BIHZ || tag == M_BINZ || tag == M_BIZ
 115           || tag == M_SYNC || tag == M_HBR)
 116         {
 117           int fb = (insn >> (32-18)) & 0x7f;
 118           if (fb & 0x40)
 119             printf(tag == M_SYNC ? "c" : "p");
 120           if (fb & 0x20)
 121             printf("d");
 122           if (fb & 0x10)
 123             printf("e");
 124         }
 125       if (index->arg[0] != 0)
 126         printf("\t");
 127       hex_value = 0;
 128       for (i = 1;  i <= index->arg[0]; i++)
 129         {
 130           int arg = index->arg[i];
 131           if (arg != A_P && !paren && i > 1)
 132             printf(",");
 133
 134           switch (arg)
 135             {
 136             case A_T:
 137               printf("$%lu",
 138                                      DECODE_INSN_RT (insn));
 139               break;
 140             case A_A:
 141               printf("$%lu",
 142                                      DECODE_INSN_RA (insn));
 143               break;
 144             case A_B:
 145               printf("$%lu",
 146                                      DECODE_INSN_RB (insn));
 147               break;
 148             case A_C:
 149               printf("$%lu",
 150                                      DECODE_INSN_RC (insn));
 151               break;
 152             case A_S:
 153               printf("$sp%lu",
 154                                      DECODE_INSN_RA (insn));
 155               break;
 156             case A_H:
 157               printf("$ch%lu",
 158                                      DECODE_INSN_RA (insn));
 159               break;
 160             case A_P:
 161               paren++;
 162               printf("(");
 163               break;
 164             case A_U7A:
 165               printf("%lu",
 166                                      173 - DECODE_INSN_U8 (insn));
 167               break;
 168             case A_U7B:
 169               printf("%lu",
 170                                      155 - DECODE_INSN_U8 (insn));
 171               break;
 172             case A_S3:
 173             case A_S6:
 174             case A_S7:
 175             case A_S7N:
 176             case A_U3:
 177             case A_U5:
 178             case A_U6:
 179             case A_U7:
 180               hex_value = DECODE_INSN_I7 (insn);
 181               printf("%d", hex_value);
 182               break;
 183             case A_S11:
 184               print_address(memaddr + DECODE_INSN_I9a (insn) * 4);
 185               break;
 186             case A_S11I:
 187               print_address(memaddr + DECODE_INSN_I9b (insn) * 4);
 188               break;
 189             case A_S10:
 190             case A_S10B:
 191               hex_value = DECODE_INSN_I10 (insn);
 192               printf("%d", hex_value);
 193               break;
 194             case A_S14:
 195               hex_value = DECODE_INSN_I10 (insn) * 16;
 196               printf("%d", hex_value);
 197               break;
 198             case A_S16:
 199               hex_value = DECODE_INSN_I16 (insn);
 200               printf("%d", hex_value);
 201               break;
 202             case A_X16:
 203               hex_value = DECODE_INSN_U16 (insn);
 204               printf("%u", hex_value);
 205               break;
 206             case A_R18:
 207               value = DECODE_INSN_I16 (insn) * 4;
 208               if (value == 0)
 209                 printf("%d", value);
 210               else
 211                 {
 212                   hex_value = memaddr + value;
 213                   print_address(hex_value & 0x3ffff);
 214                 }
 215               break;
 216             case A_S18:
 217               value = DECODE_INSN_U16 (insn) * 4;
 218               if (value == 0)
 219                 printf("%d", value);
 220               else
 221                 print_address(value);
 222               break;
 223             case A_U18:
 224               value = DECODE_INSN_U18 (insn);
 225               if (value == 0 || 1)
 226                 {
 227                   hex_value = value;
 228                   printf("%u", value);
 229                 }
 230               else
 231                 print_address(value);
 232               break;
 233             case A_U14:
 234               hex_value = DECODE_INSN_U14 (insn);
 235               printf("%u", hex_value);
 236               break;
 237             }
 238           if (arg != A_P && paren)
 239             {
 240               printf(")");
 241               paren--;
 242             }
 243         }
 244       if (hex_value > 16)
 245         printf("\t# %x", hex_value);
 246     }
 247   return 4;
 248 }