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-2017 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 "dis-asm.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); 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 CGEN_CPU_DESC cd; 345} cpu_desc_list; 346 347int 348print_insn_@arch@ (bfd_vma pc, disassemble_info *info) 349{ 350 static cpu_desc_list *cd_list = 0; 351 cpu_desc_list *cl = 0; 352 static CGEN_CPU_DESC cd = 0; 353 static CGEN_BITSET *prev_isa; 354 static int prev_mach; 355 static int prev_endian; 356 int length; 357 CGEN_BITSET *isa; 358 int mach; 359 int endian = (info->endian == BFD_ENDIAN_BIG 360 ? CGEN_ENDIAN_BIG 361 : CGEN_ENDIAN_LITTLE); 362 enum bfd_architecture arch; 363 364 /* ??? gdb will set mach but leave the architecture as "unknown" */ 365#ifndef CGEN_BFD_ARCH 366#define CGEN_BFD_ARCH bfd_arch_@arch@ 367#endif 368 arch = info->arch; 369 if (arch == bfd_arch_unknown) 370 arch = CGEN_BFD_ARCH; 371 372 /* There's no standard way to compute the machine or isa number 373 so we leave it to the target. */ 374#ifdef CGEN_COMPUTE_MACH 375 mach = CGEN_COMPUTE_MACH (info); 376#else 377 mach = info->mach; 378#endif 379 380#ifdef CGEN_COMPUTE_ISA 381 { 382 static CGEN_BITSET *permanent_isa; 383 384 if (!permanent_isa) 385 permanent_isa = cgen_bitset_create (MAX_ISAS); 386 isa = permanent_isa; 387 cgen_bitset_clear (isa); 388 cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info)); 389 } 390#else 391 isa = info->insn_sets; 392#endif 393 394 /* If we've switched cpu's, try to find a handle we've used before */ 395 if (cd 396 && (cgen_bitset_compare (isa, prev_isa) != 0 397 || mach != prev_mach 398 || endian != prev_endian)) 399 { 400 cd = 0; 401 for (cl = cd_list; cl; cl = cl->next) 402 { 403 if (cgen_bitset_compare (cl->isa, isa) == 0 && 404 cl->mach == mach && 405 cl->endian == endian) 406 { 407 cd = cl->cd; 408 prev_isa = cd->isas; 409 break; 410 } 411 } 412 } 413 414 /* If we haven't initialized yet, initialize the opcode table. */ 415 if (! cd) 416 { 417 const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach); 418 const char *mach_name; 419 420 if (!arch_type) 421 abort (); 422 mach_name = arch_type->printable_name; 423 424 prev_isa = cgen_bitset_copy (isa); 425 prev_mach = mach; 426 prev_endian = endian; 427 cd = @arch@_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa, 428 CGEN_CPU_OPEN_BFDMACH, mach_name, 429 CGEN_CPU_OPEN_ENDIAN, prev_endian, 430 CGEN_CPU_OPEN_END); 431 if (!cd) 432 abort (); 433 434 /* Save this away for future reference. */ 435 cl = xmalloc (sizeof (struct cpu_desc_list)); 436 cl->cd = cd; 437 cl->isa = prev_isa; 438 cl->mach = mach; 439 cl->endian = endian; 440 cl->next = cd_list; 441 cd_list = cl; 442 443 @arch@_cgen_init_dis (cd); 444 } 445 446 /* We try to have as much common code as possible. 447 But at this point some targets need to take over. */ 448 /* ??? Some targets may need a hook elsewhere. Try to avoid this, 449 but if not possible try to move this hook elsewhere rather than 450 have two hooks. */ 451 length = CGEN_PRINT_INSN (cd, pc, info); 452 if (length > 0) 453 return length; 454 if (length < 0) 455 return -1; 456 457 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 458 return cd->default_insn_bitsize / 8; 459} 460