[POWERPC] Make xmon disassembly optional
[linux-2.6.git] / arch / powerpc / xmon / 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 "nonstdio.h"
22 #include "ansidecl.h"
23 #include "ppc.h"
24 #include "dis-asm.h"
25
26 /* Print a PowerPC or POWER instruction.  */
27
28 int
29 print_insn_powerpc (unsigned long insn, unsigned long memaddr)
30 {
31   const struct powerpc_opcode *opcode;
32   const struct powerpc_opcode *opcode_end;
33   unsigned long op;
34   int dialect;
35
36   dialect = PPC_OPCODE_PPC | PPC_OPCODE_CLASSIC | PPC_OPCODE_COMMON
37               | PPC_OPCODE_64 | PPC_OPCODE_POWER4 | PPC_OPCODE_ALTIVEC;
38
39   /* Get the major opcode of the instruction.  */
40   op = PPC_OP (insn);
41
42   /* Find the first match in the opcode table.  We could speed this up
43      a bit by doing a binary search on the major opcode.  */
44   opcode_end = powerpc_opcodes + powerpc_num_opcodes;
45  again:
46   for (opcode = powerpc_opcodes; opcode < opcode_end; opcode++)
47     {
48       unsigned long table_op;
49       const unsigned char *opindex;
50       const struct powerpc_operand *operand;
51       int invalid;
52       int need_comma;
53       int need_paren;
54
55       table_op = PPC_OP (opcode->opcode);
56       if (op < table_op)
57         break;
58       if (op > table_op)
59         continue;
60
61       if ((insn & opcode->mask) != opcode->opcode
62           || (opcode->flags & dialect) == 0)
63         continue;
64
65       /* Make two passes over the operands.  First see if any of them
66          have extraction functions, and, if they do, make sure the
67          instruction is valid.  */
68       invalid = 0;
69       for (opindex = opcode->operands; *opindex != 0; opindex++)
70         {
71           operand = powerpc_operands + *opindex;
72           if (operand->extract)
73             (*operand->extract) (insn, dialect, &invalid);
74         }
75       if (invalid)
76         continue;
77
78       /* The instruction is valid.  */
79       printf("%s", opcode->name);
80       if (opcode->operands[0] != 0)
81         printf("\t");
82
83       /* Now extract and print the operands.  */
84       need_comma = 0;
85       need_paren = 0;
86       for (opindex = opcode->operands; *opindex != 0; opindex++)
87         {
88           long value;
89
90           operand = powerpc_operands + *opindex;
91
92           /* Operands that are marked FAKE are simply ignored.  We
93              already made sure that the extract function considered
94              the instruction to be valid.  */
95           if ((operand->flags & PPC_OPERAND_FAKE) != 0)
96             continue;
97
98           /* Extract the value from the instruction.  */
99           if (operand->extract)
100             value = (*operand->extract) (insn, dialect, &invalid);
101           else
102             {
103               value = (insn >> operand->shift) & ((1 << operand->bits) - 1);
104               if ((operand->flags & PPC_OPERAND_SIGNED) != 0
105                   && (value & (1 << (operand->bits - 1))) != 0)
106                 value -= 1 << operand->bits;
107             }
108
109           /* If the operand is optional, and the value is zero, don't
110              print anything.  */
111           if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
112               && (operand->flags & PPC_OPERAND_NEXT) == 0
113               && value == 0)
114             continue;
115
116           if (need_comma)
117             {
118               printf(",");
119               need_comma = 0;
120             }
121
122           /* Print the operand as directed by the flags.  */
123           if ((operand->flags & PPC_OPERAND_GPR) != 0)
124             printf("r%ld", value);
125           else if ((operand->flags & PPC_OPERAND_FPR) != 0)
126             printf("f%ld", value);
127           else if ((operand->flags & PPC_OPERAND_VR) != 0)
128             printf("v%ld", value);
129           else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0)
130             print_address (memaddr + value);
131           else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
132             print_address (value & 0xffffffff);
133           else if ((operand->flags & PPC_OPERAND_CR) == 0
134                    || (dialect & PPC_OPCODE_PPC) == 0)
135             printf("%ld", value);
136           else
137             {
138               if (operand->bits == 3)
139                 printf("cr%d", value);
140               else
141                 {
142                   static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
143                   int cr;
144                   int cc;
145
146                   cr = value >> 2;
147                   if (cr != 0)
148                     printf("4*cr%d+", cr);
149                   cc = value & 3;
150                   printf("%s", cbnames[cc]);
151                 }
152             }
153
154           if (need_paren)
155             {
156               printf(")");
157               need_paren = 0;
158             }
159
160           if ((operand->flags & PPC_OPERAND_PARENS) == 0)
161             need_comma = 1;
162           else
163             {
164               printf("(");
165               need_paren = 1;
166             }
167         }
168
169       /* We have found and printed an instruction; return.  */
170       return 4;
171     }
172
173   if ((dialect & PPC_OPCODE_ANY) != 0)
174     {
175       dialect = ~PPC_OPCODE_ANY;
176       goto again;
177     }
178
179   /* We could not find a match.  */
180   printf(".long 0x%lx", insn);
181
182   return 4;
183 }