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 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 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 * 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 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