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
6This 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
25static long
26operand_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
58static int
59skip_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
80static const struct powerpc_opcode *
81lookup_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
119int 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