1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /* ppc-dis.c -- Disassemble PowerPC instructions
3 Copyright (C) 1994-2016 Free Software Foundation, Inc.
4 Written by Ian Lance Taylor, Cygnus Support
5
6 This file is part of GDB, GAS, and the GNU binutils.
7
8 */
9
10 #include <asm/cputable.h>
11 #include <asm/cpu_has_feature.h>
12 #include "nonstdio.h"
13 #include "ansidecl.h"
14 #include "ppc.h"
15 #include "dis-asm.h"
16
17 /* This file provides several disassembler functions, all of which use
18 the disassembler interface defined in dis-asm.h. Several functions
19 are provided because this file handles disassembly for the PowerPC
20 in both big and little endian mode and also for the POWER (RS/6000)
21 chip. */
22
23 /* Extract the operand value from the PowerPC or POWER instruction. */
24
25 static long
operand_value_powerpc(const struct powerpc_operand * operand,unsigned long insn,ppc_cpu_t dialect)26 operand_value_powerpc (const struct powerpc_operand *operand,
27 unsigned long insn, ppc_cpu_t dialect)
28 {
29 long value;
30 int invalid;
31 /* Extract the value from the instruction. */
32 if (operand->extract)
33 value = (*operand->extract) (insn, dialect, &invalid);
34 else
35 {
36 if (operand->shift >= 0)
37 value = (insn >> operand->shift) & operand->bitm;
38 else
39 value = (insn << -operand->shift) & operand->bitm;
40 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
41 {
42 /* BITM is always some number of zeros followed by some
43 number of ones, followed by some number of zeros. */
44 unsigned long top = operand->bitm;
45 /* top & -top gives the rightmost 1 bit, so this
46 fills in any trailing zeros. */
47 top |= (top & -top) - 1;
48 top &= ~(top >> 1);
49 value = (value ^ top) - top;
50 }
51 }
52
53 return value;
54 }
55
56 /* Determine whether the optional operand(s) should be printed. */
57
58 static int
skip_optional_operands(const unsigned char * opindex,unsigned long insn,ppc_cpu_t dialect)59 skip_optional_operands (const unsigned char *opindex,
60 unsigned long insn, ppc_cpu_t dialect)
61 {
62 const struct powerpc_operand *operand;
63
64 for (; *opindex != 0; opindex++)
65 {
66 operand = &powerpc_operands[*opindex];
67 if ((operand->flags & PPC_OPERAND_NEXT) != 0
68 || ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
69 && operand_value_powerpc (operand, insn, dialect) !=
70 ppc_optional_operand_value (operand)))
71 return 0;
72 }
73
74 return 1;
75 }
76
77 /* Find a match for INSN in the opcode table, given machine DIALECT.
78 A DIALECT of -1 is special, matching all machine opcode variations. */
79
80 static const struct powerpc_opcode *
lookup_powerpc(unsigned long insn,ppc_cpu_t dialect)81 lookup_powerpc (unsigned long insn, ppc_cpu_t dialect)
82 {
83 const struct powerpc_opcode *opcode;
84 const struct powerpc_opcode *opcode_end;
85
86 opcode_end = powerpc_opcodes + powerpc_num_opcodes;
87 /* Find the first match in the opcode table for this major opcode. */
88 for (opcode = powerpc_opcodes; opcode < opcode_end; ++opcode)
89 {
90 const unsigned char *opindex;
91 const struct powerpc_operand *operand;
92 int invalid;
93
94 if ((insn & opcode->mask) != opcode->opcode
95 || (dialect != (ppc_cpu_t) -1
96 && ((opcode->flags & dialect) == 0
97 || (opcode->deprecated & dialect) != 0)))
98 continue;
99
100 /* Check validity of operands. */
101 invalid = 0;
102 for (opindex = opcode->operands; *opindex != 0; opindex++)
103 {
104 operand = powerpc_operands + *opindex;
105 if (operand->extract)
106 (*operand->extract) (insn, dialect, &invalid);
107 }
108 if (invalid)
109 continue;
110
111 return opcode;
112 }
113
114 return NULL;
115 }
116
117 /* Print a PowerPC or POWER instruction. */
118
print_insn_powerpc(unsigned long insn,unsigned long memaddr)119 int print_insn_powerpc (unsigned long insn, unsigned long memaddr)
120 {
121 const struct powerpc_opcode *opcode;
122 bool insn_is_short;
123 ppc_cpu_t dialect;
124
125 dialect = PPC_OPCODE_PPC | PPC_OPCODE_COMMON
126 | PPC_OPCODE_64 | PPC_OPCODE_POWER4 | PPC_OPCODE_ALTIVEC;
127
128 if (cpu_has_feature(CPU_FTRS_POWER5))
129 dialect |= PPC_OPCODE_POWER5;
130
131 if (cpu_has_feature(CPU_FTRS_CELL))
132 dialect |= (PPC_OPCODE_CELL | PPC_OPCODE_ALTIVEC);
133
134 if (cpu_has_feature(CPU_FTRS_POWER6))
135 dialect |= (PPC_OPCODE_POWER5 | PPC_OPCODE_POWER6 | PPC_OPCODE_ALTIVEC);
136
137 if (cpu_has_feature(CPU_FTRS_POWER7))
138 dialect |= (PPC_OPCODE_POWER5 | PPC_OPCODE_POWER6 | PPC_OPCODE_POWER7
139 | PPC_OPCODE_ALTIVEC | PPC_OPCODE_VSX);
140
141 if (cpu_has_feature(CPU_FTRS_POWER8))
142 dialect |= (PPC_OPCODE_POWER5 | PPC_OPCODE_POWER6 | PPC_OPCODE_POWER7
143 | PPC_OPCODE_POWER8 | PPC_OPCODE_HTM
144 | PPC_OPCODE_ALTIVEC | PPC_OPCODE_ALTIVEC2 | PPC_OPCODE_VSX);
145
146 if (cpu_has_feature(CPU_FTRS_POWER9))
147 dialect |= (PPC_OPCODE_POWER5 | PPC_OPCODE_POWER6 | PPC_OPCODE_POWER7
148 | PPC_OPCODE_POWER8 | PPC_OPCODE_POWER9 | PPC_OPCODE_HTM
149 | PPC_OPCODE_ALTIVEC | PPC_OPCODE_ALTIVEC2
150 | PPC_OPCODE_VSX | PPC_OPCODE_VSX3);
151
152 /* Get the major opcode of the insn. */
153 opcode = NULL;
154 insn_is_short = false;
155
156 if (opcode == NULL)
157 opcode = lookup_powerpc (insn, dialect);
158 if (opcode == NULL && (dialect & PPC_OPCODE_ANY) != 0)
159 opcode = lookup_powerpc (insn, (ppc_cpu_t) -1);
160
161 if (opcode != NULL)
162 {
163 const unsigned char *opindex;
164 const struct powerpc_operand *operand;
165 int need_comma;
166 int need_paren;
167 int skip_optional;
168
169 if (opcode->operands[0] != 0)
170 printf("%-7s ", opcode->name);
171 else
172 printf("%s", opcode->name);
173
174 if (insn_is_short)
175 /* The operands will be fetched out of the 16-bit instruction. */
176 insn >>= 16;
177
178 /* Now extract and print the operands. */
179 need_comma = 0;
180 need_paren = 0;
181 skip_optional = -1;
182 for (opindex = opcode->operands; *opindex != 0; opindex++)
183 {
184 long value;
185
186 operand = powerpc_operands + *opindex;
187
188 /* Operands that are marked FAKE are simply ignored. We
189 already made sure that the extract function considered
190 the instruction to be valid. */
191 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
192 continue;
193
194 /* If all of the optional operands have the value zero,
195 then don't print any of them. */
196 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
197 {
198 if (skip_optional < 0)
199 skip_optional = skip_optional_operands (opindex, insn,
200 dialect);
201 if (skip_optional)
202 continue;
203 }
204
205 value = operand_value_powerpc (operand, insn, dialect);
206
207 if (need_comma)
208 {
209 printf(",");
210 need_comma = 0;
211 }
212
213 /* Print the operand as directed by the flags. */
214 if ((operand->flags & PPC_OPERAND_GPR) != 0
215 || ((operand->flags & PPC_OPERAND_GPR_0) != 0 && value != 0))
216 printf("r%ld", value);
217 else if ((operand->flags & PPC_OPERAND_FPR) != 0)
218 printf("f%ld", value);
219 else if ((operand->flags & PPC_OPERAND_VR) != 0)
220 printf("v%ld", value);
221 else if ((operand->flags & PPC_OPERAND_VSR) != 0)
222 printf("vs%ld", value);
223 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0)
224 print_address(memaddr + value);
225 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
226 print_address(value & 0xffffffff);
227 else if ((operand->flags & PPC_OPERAND_FSL) != 0)
228 printf("fsl%ld", value);
229 else if ((operand->flags & PPC_OPERAND_FCR) != 0)
230 printf("fcr%ld", value);
231 else if ((operand->flags & PPC_OPERAND_UDI) != 0)
232 printf("%ld", value);
233 else if ((operand->flags & PPC_OPERAND_CR_REG) != 0
234 && (((dialect & PPC_OPCODE_PPC) != 0)
235 || ((dialect & PPC_OPCODE_VLE) != 0)))
236 printf("cr%ld", value);
237 else if (((operand->flags & PPC_OPERAND_CR_BIT) != 0)
238 && (((dialect & PPC_OPCODE_PPC) != 0)
239 || ((dialect & PPC_OPCODE_VLE) != 0)))
240 {
241 static const char *cbnames[4] = { "lt", "gt", "eq", "so" };
242 int cr;
243 int cc;
244
245 cr = value >> 2;
246 if (cr != 0)
247 printf("4*cr%d+", cr);
248 cc = value & 3;
249 printf("%s", cbnames[cc]);
250 }
251 else
252 printf("%d", (int) value);
253
254 if (need_paren)
255 {
256 printf(")");
257 need_paren = 0;
258 }
259
260 if ((operand->flags & PPC_OPERAND_PARENS) == 0)
261 need_comma = 1;
262 else
263 {
264 printf("(");
265 need_paren = 1;
266 }
267 }
268
269 /* We have found and printed an instruction.
270 If it was a short VLE instruction we have more to do. */
271 if (insn_is_short)
272 {
273 memaddr += 2;
274 return 2;
275 }
276 else
277 /* Otherwise, return. */
278 return 4;
279 }
280
281 /* We could not find a match. */
282 printf(".long 0x%lx", insn);
283
284 return 4;
285 }
286