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