1/* Disassembler interface for targets using CGEN. -*- C -*- 2 CGEN: Cpu tools GENerator 3 4 THIS FILE IS MACHINE GENERATED WITH CGEN. 5 - the resultant file is machine generated, cgen-dis.in isn't 6 7 Copyright (C) 1996-2022 Free Software Foundation, Inc. 8 9 This file is part of libopcodes. 10 11 This library is free software; you can redistribute it and/or modify 12 it under the terms of the GNU General Public License as published by 13 the Free Software Foundation; either version 3, or (at your option) 14 any later version. 15 16 It is distributed in the hope that it will be useful, but WITHOUT 17 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 18 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 19 License for more details. 20 21 You should have received a copy of the GNU General Public License 22 along with this program; if not, write to the Free Software Foundation, Inc., 23 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 24 25/* ??? Eventually more and more of this stuff can go to cpu-independent files. 26 Keep that in mind. */ 27 28#include "sysdep.h" 29#include <stdio.h> 30#include "ansidecl.h" 31#include "disassemble.h" 32#include "bfd.h" 33#include "symcat.h" 34#include "libiberty.h" 35#include "@prefix@-desc.h" 36#include "@prefix@-opc.h" 37#include "opintl.h" 38 39/* Default text to print if an instruction isn't recognized. */ 40#define UNKNOWN_INSN_MSG _("*unknown*") 41 42static void print_normal 43 (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int); 44static void print_address 45 (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED; 46static void print_keyword 47 (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED; 48static void print_insn_normal 49 (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int); 50static int print_insn 51 (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, unsigned); 52static int default_print_insn 53 (CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED; 54static int read_insn 55 (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, int, CGEN_EXTRACT_INFO *, 56 unsigned long *); 57 58/* -- disassembler routines inserted here. */ 59 60/* Default print handler. */ 61 62static void 63print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 64 void *dis_info, 65 long value, 66 unsigned int attrs, 67 bfd_vma pc ATTRIBUTE_UNUSED, 68 int length ATTRIBUTE_UNUSED) 69{ 70 disassemble_info *info = (disassemble_info *) dis_info; 71 72 /* Print the operand as directed by the attributes. */ 73 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY)) 74 ; /* nothing to do */ 75 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED)) 76 (*info->fprintf_func) (info->stream, "%ld", value); 77 else 78 (*info->fprintf_func) (info->stream, "0x%lx", value); 79} 80 81/* Default address handler. */ 82 83static void 84print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 85 void *dis_info, 86 bfd_vma value, 87 unsigned int attrs, 88 bfd_vma pc ATTRIBUTE_UNUSED, 89 int length ATTRIBUTE_UNUSED) 90{ 91 disassemble_info *info = (disassemble_info *) dis_info; 92 93 /* Print the operand as directed by the attributes. */ 94 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY)) 95 ; /* Nothing to do. */ 96 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR)) 97 (*info->print_address_func) (value, info); 98 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR)) 99 (*info->print_address_func) (value, info); 100 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED)) 101 (*info->fprintf_func) (info->stream, "%ld", (long) value); 102 else 103 (*info->fprintf_func) (info->stream, "0x%lx", (long) value); 104} 105 106/* Keyword print handler. */ 107 108static void 109print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 110 void *dis_info, 111 CGEN_KEYWORD *keyword_table, 112 long value, 113 unsigned int attrs ATTRIBUTE_UNUSED) 114{ 115 disassemble_info *info = (disassemble_info *) dis_info; 116 const CGEN_KEYWORD_ENTRY *ke; 117 118 ke = cgen_keyword_lookup_value (keyword_table, value); 119 if (ke != NULL) 120 (*info->fprintf_func) (info->stream, "%s", ke->name); 121 else 122 (*info->fprintf_func) (info->stream, "???"); 123} 124 125/* Default insn printer. 126 127 DIS_INFO is defined as `void *' so the disassembler needn't know anything 128 about disassemble_info. */ 129 130static void 131print_insn_normal (CGEN_CPU_DESC cd, 132 void *dis_info, 133 const CGEN_INSN *insn, 134 CGEN_FIELDS *fields, 135 bfd_vma pc, 136 int length) 137{ 138 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 139 disassemble_info *info = (disassemble_info *) dis_info; 140 const CGEN_SYNTAX_CHAR_TYPE *syn; 141 142 CGEN_INIT_PRINT (cd); 143 144 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn) 145 { 146 if (CGEN_SYNTAX_MNEMONIC_P (*syn)) 147 { 148 (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn)); 149 continue; 150 } 151 if (CGEN_SYNTAX_CHAR_P (*syn)) 152 { 153 (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn)); 154 continue; 155 } 156 157 /* We have an operand. */ 158 @arch@_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info, 159 fields, CGEN_INSN_ATTRS (insn), pc, length); 160 } 161} 162 163/* Subroutine of print_insn. Reads an insn into the given buffers and updates 164 the extract info. 165 Returns 0 if all is well, non-zero otherwise. */ 166 167static int 168read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 169 bfd_vma pc, 170 disassemble_info *info, 171 bfd_byte *buf, 172 int buflen, 173 CGEN_EXTRACT_INFO *ex_info, 174 unsigned long *insn_value) 175{ 176 int status = (*info->read_memory_func) (pc, buf, buflen, info); 177 178 if (status != 0) 179 { 180 (*info->memory_error_func) (status, pc, info); 181 return -1; 182 } 183 184 ex_info->dis_info = info; 185 ex_info->valid = (1 << buflen) - 1; 186 ex_info->insn_bytes = buf; 187 188 *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG); 189 return 0; 190} 191 192/* Utility to print an insn. 193 BUF is the base part of the insn, target byte order, BUFLEN bytes long. 194 The result is the size of the insn in bytes or zero for an unknown insn 195 or -1 if an error occurs fetching data (memory_error_func will have 196 been called). */ 197 198static int 199print_insn (CGEN_CPU_DESC cd, 200 bfd_vma pc, 201 disassemble_info *info, 202 bfd_byte *buf, 203 unsigned int buflen) 204{ 205 CGEN_INSN_INT insn_value; 206 const CGEN_INSN_LIST *insn_list; 207 CGEN_EXTRACT_INFO ex_info; 208 int basesize; 209 210 /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */ 211 basesize = cd->base_insn_bitsize < buflen * 8 ? 212 cd->base_insn_bitsize : buflen * 8; 213 insn_value = cgen_get_insn_value (cd, buf, basesize, cd->insn_endian); 214 215 216 /* Fill in ex_info fields like read_insn would. Don't actually call 217 read_insn, since the incoming buffer is already read (and possibly 218 modified a la m32r). */ 219 ex_info.valid = (1 << buflen) - 1; 220 ex_info.dis_info = info; 221 ex_info.insn_bytes = buf; 222 223 /* The instructions are stored in hash lists. 224 Pick the first one and keep trying until we find the right one. */ 225 226 insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value); 227 while (insn_list != NULL) 228 { 229 const CGEN_INSN *insn = insn_list->insn; 230 CGEN_FIELDS fields; 231 int length; 232 unsigned long insn_value_cropped; 233 234#ifdef CGEN_VALIDATE_INSN_SUPPORTED 235 /* Not needed as insn shouldn't be in hash lists if not supported. */ 236 /* Supported by this cpu? */ 237 if (! @arch@_cgen_insn_supported (cd, insn)) 238 { 239 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 240 continue; 241 } 242#endif 243 244 /* Basic bit mask must be correct. */ 245 /* ??? May wish to allow target to defer this check until the extract 246 handler. */ 247 248 /* Base size may exceed this instruction's size. Extract the 249 relevant part from the buffer. */ 250 if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen && 251 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long)) 252 insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn), 253 info->endian == BFD_ENDIAN_BIG); 254 else 255 insn_value_cropped = insn_value; 256 257 if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn)) 258 == CGEN_INSN_BASE_VALUE (insn)) 259 { 260 /* Printing is handled in two passes. The first pass parses the 261 machine insn and extracts the fields. The second pass prints 262 them. */ 263 264 /* Make sure the entire insn is loaded into insn_value, if it 265 can fit. */ 266 if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) && 267 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long)) 268 { 269 unsigned long full_insn_value; 270 int rc = read_insn (cd, pc, info, buf, 271 CGEN_INSN_BITSIZE (insn) / 8, 272 & ex_info, & full_insn_value); 273 if (rc != 0) 274 return rc; 275 length = CGEN_EXTRACT_FN (cd, insn) 276 (cd, insn, &ex_info, full_insn_value, &fields, pc); 277 } 278 else 279 length = CGEN_EXTRACT_FN (cd, insn) 280 (cd, insn, &ex_info, insn_value_cropped, &fields, pc); 281 282 /* Length < 0 -> error. */ 283 if (length < 0) 284 return length; 285 if (length > 0) 286 { 287 CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length); 288 /* Length is in bits, result is in bytes. */ 289 return length / 8; 290 } 291 } 292 293 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 294 } 295 296 return 0; 297} 298 299/* Default value for CGEN_PRINT_INSN. 300 The result is the size of the insn in bytes or zero for an unknown insn 301 or -1 if an error occured fetching bytes. */ 302 303#ifndef CGEN_PRINT_INSN 304#define CGEN_PRINT_INSN default_print_insn 305#endif 306 307static int 308default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 309{ 310 bfd_byte buf[CGEN_MAX_INSN_SIZE]; 311 int buflen; 312 int status; 313 314 /* Attempt to read the base part of the insn. */ 315 buflen = cd->base_insn_bitsize / 8; 316 status = (*info->read_memory_func) (pc, buf, buflen, info); 317 318 /* Try again with the minimum part, if min < base. */ 319 if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize)) 320 { 321 buflen = cd->min_insn_bitsize / 8; 322 status = (*info->read_memory_func) (pc, buf, buflen, info); 323 } 324 325 if (status != 0) 326 { 327 (*info->memory_error_func) (status, pc, info); 328 return -1; 329 } 330 331 return print_insn (cd, pc, info, buf, buflen); 332} 333 334/* Main entry point. 335 Print one instruction from PC on INFO->STREAM. 336 Return the size of the instruction (in bytes). */ 337 338typedef struct cpu_desc_list 339{ 340 struct cpu_desc_list *next; 341 CGEN_BITSET *isa; 342 int mach; 343 int endian; 344 int insn_endian; 345 CGEN_CPU_DESC cd; 346} cpu_desc_list; 347 348int 349print_insn_@arch@ (bfd_vma pc, disassemble_info *info) 350{ 351 static cpu_desc_list *cd_list = 0; 352 cpu_desc_list *cl = 0; 353 static CGEN_CPU_DESC cd = 0; 354 static CGEN_BITSET *prev_isa; 355 static int prev_mach; 356 static int prev_endian; 357 static int prev_insn_endian; 358 int length; 359 CGEN_BITSET *isa; 360 int mach; 361 int endian = (info->endian == BFD_ENDIAN_BIG 362 ? CGEN_ENDIAN_BIG 363 : CGEN_ENDIAN_LITTLE); 364 int insn_endian = (info->endian_code == BFD_ENDIAN_BIG 365 ? CGEN_ENDIAN_BIG 366 : CGEN_ENDIAN_LITTLE); 367 enum bfd_architecture arch; 368 369 /* ??? gdb will set mach but leave the architecture as "unknown" */ 370#ifndef CGEN_BFD_ARCH 371#define CGEN_BFD_ARCH bfd_arch_@arch@ 372#endif 373 arch = info->arch; 374 if (arch == bfd_arch_unknown) 375 arch = CGEN_BFD_ARCH; 376 377 /* There's no standard way to compute the machine or isa number 378 so we leave it to the target. */ 379#ifdef CGEN_COMPUTE_MACH 380 mach = CGEN_COMPUTE_MACH (info); 381#else 382 mach = info->mach; 383#endif 384 385#ifdef CGEN_COMPUTE_ISA 386 { 387 static CGEN_BITSET *permanent_isa; 388 389 if (!permanent_isa) 390 permanent_isa = cgen_bitset_create (MAX_ISAS); 391 isa = permanent_isa; 392 cgen_bitset_clear (isa); 393 cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info)); 394 } 395#else 396 isa = info->private_data; 397#endif 398 399 /* If we've switched cpu's, try to find a handle we've used before */ 400 if (cd 401 && (cgen_bitset_compare (isa, prev_isa) != 0 402 || mach != prev_mach 403 || endian != prev_endian)) 404 { 405 cd = 0; 406 for (cl = cd_list; cl; cl = cl->next) 407 { 408 if (cgen_bitset_compare (cl->isa, isa) == 0 && 409 cl->mach == mach && 410 cl->endian == endian) 411 { 412 cd = cl->cd; 413 prev_isa = cd->isas; 414 break; 415 } 416 } 417 } 418 419 /* If we haven't initialized yet, initialize the opcode table. */ 420 if (! cd) 421 { 422 const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach); 423 const char *mach_name; 424 425 if (!arch_type) 426 abort (); 427 mach_name = arch_type->printable_name; 428 429 prev_isa = cgen_bitset_copy (isa); 430 prev_mach = mach; 431 prev_endian = endian; 432 prev_insn_endian = insn_endian; 433 cd = @arch@_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa, 434 CGEN_CPU_OPEN_BFDMACH, mach_name, 435 CGEN_CPU_OPEN_ENDIAN, prev_endian, 436 CGEN_CPU_OPEN_INSN_ENDIAN, prev_insn_endian, 437 CGEN_CPU_OPEN_END); 438 if (!cd) 439 abort (); 440 441 /* Save this away for future reference. */ 442 cl = xmalloc (sizeof (struct cpu_desc_list)); 443 cl->cd = cd; 444 cl->isa = prev_isa; 445 cl->mach = mach; 446 cl->endian = endian; 447 cl->next = cd_list; 448 cd_list = cl; 449 450 @arch@_cgen_init_dis (cd); 451 } 452 453 /* We try to have as much common code as possible. 454 But at this point some targets need to take over. */ 455 /* ??? Some targets may need a hook elsewhere. Try to avoid this, 456 but if not possible try to move this hook elsewhere rather than 457 have two hooks. */ 458 length = CGEN_PRINT_INSN (cd, pc, info); 459 if (length > 0) 460 return length; 461 if (length < 0) 462 return -1; 463 464 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 465 return cd->default_insn_bitsize / 8; 466} 467