1 /* DO NOT EDIT! -*- buffer-read-only: t -*- vi:set ro: */ 2 /* Disassembler interface for targets using CGEN. -*- C -*- 3 CGEN: Cpu tools GENerator 4 5 THIS FILE IS MACHINE GENERATED WITH CGEN. 6 - the resultant file is machine generated, cgen-dis.in isn't 7 8 Copyright (C) 1996-2018 Free Software Foundation, Inc. 9 10 This file is part of libopcodes. 11 12 This library 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 3, or (at your option) 15 any later version. 16 17 It is distributed in the hope that it will be useful, but WITHOUT 18 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 19 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 20 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 "disassemble.h" 33 #include "bfd.h" 34 #include "symcat.h" 35 #include "libiberty.h" 36 #include "epiphany-desc.h" 37 #include "epiphany-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 43 static void print_normal 44 (CGEN_CPU_DESC, void *, long, unsigned int, bfd_vma, int); 45 static void print_address 46 (CGEN_CPU_DESC, void *, bfd_vma, unsigned int, bfd_vma, int) ATTRIBUTE_UNUSED; 47 static void print_keyword 48 (CGEN_CPU_DESC, void *, CGEN_KEYWORD *, long, unsigned int) ATTRIBUTE_UNUSED; 49 static void print_insn_normal 50 (CGEN_CPU_DESC, void *, const CGEN_INSN *, CGEN_FIELDS *, bfd_vma, int); 51 static int print_insn 52 (CGEN_CPU_DESC, bfd_vma, disassemble_info *, bfd_byte *, unsigned); 53 static int default_print_insn 54 (CGEN_CPU_DESC, bfd_vma, disassemble_info *) ATTRIBUTE_UNUSED; 55 static 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 /* -- dis.c */ 62 63 #define CGEN_PRINT_INSN epiphany_print_insn 64 65 static int 66 epiphany_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 67 { 68 bfd_byte buf[CGEN_MAX_INSN_SIZE]; 69 int buflen; 70 int status; 71 72 info->bytes_per_chunk = 2; 73 info->bytes_per_line = 4; 74 75 /* Attempt to read the base part of the insn. */ 76 buflen = cd->base_insn_bitsize / 8; 77 status = (*info->read_memory_func) (pc, buf, buflen, info); 78 79 /* Try again with the minimum part, if min < base. */ 80 if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize)) 81 { 82 buflen = cd->min_insn_bitsize / 8; 83 status = (*info->read_memory_func) (pc, buf, buflen, info); 84 } 85 86 if (status != 0) 87 { 88 (*info->memory_error_func) (status, pc, info); 89 return -1; 90 } 91 92 return print_insn (cd, pc, info, buf, buflen); 93 } 94 95 96 static void 97 print_postindex (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 98 void * dis_info, 99 long value, 100 unsigned int attrs ATTRIBUTE_UNUSED, 101 bfd_vma pc ATTRIBUTE_UNUSED, 102 int length ATTRIBUTE_UNUSED) 103 { 104 disassemble_info *info = (disassemble_info *) dis_info; 105 (*info->fprintf_func) (info->stream, value ? "-" : "+"); 106 } 107 108 static void 109 print_simm_not_reg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 110 void * dis_info, 111 long value, 112 unsigned int attrs ATTRIBUTE_UNUSED, 113 bfd_vma pc ATTRIBUTE_UNUSED, 114 int length ATTRIBUTE_UNUSED) 115 { 116 print_address (cd, dis_info, value, attrs, pc, length); 117 } 118 119 static void 120 print_uimm_not_reg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 121 void * dis_info, 122 unsigned long value, 123 unsigned int attrs ATTRIBUTE_UNUSED, 124 bfd_vma pc ATTRIBUTE_UNUSED, 125 int length ATTRIBUTE_UNUSED) 126 { 127 disassemble_info *info = (disassemble_info *)dis_info; 128 129 if (value & 0x800) 130 (*info->fprintf_func) (info->stream, "-"); 131 132 value &= 0x7ff; 133 print_address (cd, dis_info, value, attrs, pc, length); 134 } 135 136 137 /* -- */ 138 139 void epiphany_cgen_print_operand 140 (CGEN_CPU_DESC, int, PTR, CGEN_FIELDS *, void const *, bfd_vma, int); 141 142 /* Main entry point for printing operands. 143 XINFO is a `void *' and not a `disassemble_info *' to not put a requirement 144 of dis-asm.h on cgen.h. 145 146 This function is basically just a big switch statement. Earlier versions 147 used tables to look up the function to use, but 148 - if the table contains both assembler and disassembler functions then 149 the disassembler contains much of the assembler and vice-versa, 150 - there's a lot of inlining possibilities as things grow, 151 - using a switch statement avoids the function call overhead. 152 153 This function could be moved into `print_insn_normal', but keeping it 154 separate makes clear the interface between `print_insn_normal' and each of 155 the handlers. */ 156 157 void 158 epiphany_cgen_print_operand (CGEN_CPU_DESC cd, 159 int opindex, 160 void * xinfo, 161 CGEN_FIELDS *fields, 162 void const *attrs ATTRIBUTE_UNUSED, 163 bfd_vma pc, 164 int length) 165 { 166 disassemble_info *info = (disassemble_info *) xinfo; 167 168 switch (opindex) 169 { 170 case EPIPHANY_OPERAND_DIRECTION : 171 print_postindex (cd, info, fields->f_addsubx, 0, pc, length); 172 break; 173 case EPIPHANY_OPERAND_DISP11 : 174 print_uimm_not_reg (cd, info, fields->f_disp11, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 175 break; 176 case EPIPHANY_OPERAND_DISP3 : 177 print_normal (cd, info, fields->f_disp3, 0, pc, length); 178 break; 179 case EPIPHANY_OPERAND_DPMI : 180 print_postindex (cd, info, fields->f_subd, 0, pc, length); 181 break; 182 case EPIPHANY_OPERAND_FRD : 183 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd, 0); 184 break; 185 case EPIPHANY_OPERAND_FRD6 : 186 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 187 break; 188 case EPIPHANY_OPERAND_FRM : 189 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm, 0); 190 break; 191 case EPIPHANY_OPERAND_FRM6 : 192 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 193 break; 194 case EPIPHANY_OPERAND_FRN : 195 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn, 0); 196 break; 197 case EPIPHANY_OPERAND_FRN6 : 198 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 199 break; 200 case EPIPHANY_OPERAND_IMM16 : 201 print_address (cd, info, fields->f_imm16, 0|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 202 break; 203 case EPIPHANY_OPERAND_IMM8 : 204 print_address (cd, info, fields->f_imm8, 0|(1<<CGEN_OPERAND_RELAX), pc, length); 205 break; 206 case EPIPHANY_OPERAND_RD : 207 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd, 0); 208 break; 209 case EPIPHANY_OPERAND_RD6 : 210 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rd6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 211 break; 212 case EPIPHANY_OPERAND_RM : 213 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm, 0); 214 break; 215 case EPIPHANY_OPERAND_RM6 : 216 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rm6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 217 break; 218 case EPIPHANY_OPERAND_RN : 219 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn, 0); 220 break; 221 case EPIPHANY_OPERAND_RN6 : 222 print_keyword (cd, info, & epiphany_cgen_opval_gr_names, fields->f_rn6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 223 break; 224 case EPIPHANY_OPERAND_SD : 225 print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sd, 0); 226 break; 227 case EPIPHANY_OPERAND_SD6 : 228 print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 229 break; 230 case EPIPHANY_OPERAND_SDDMA : 231 print_keyword (cd, info, & epiphany_cgen_opval_crdma_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 232 break; 233 case EPIPHANY_OPERAND_SDMEM : 234 print_keyword (cd, info, & epiphany_cgen_opval_crmem_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 235 break; 236 case EPIPHANY_OPERAND_SDMESH : 237 print_keyword (cd, info, & epiphany_cgen_opval_crmesh_names, fields->f_sd6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 238 break; 239 case EPIPHANY_OPERAND_SHIFT : 240 print_normal (cd, info, fields->f_shift, 0, pc, length); 241 break; 242 case EPIPHANY_OPERAND_SIMM11 : 243 print_simm_not_reg (cd, info, fields->f_sdisp11, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 244 break; 245 case EPIPHANY_OPERAND_SIMM24 : 246 print_address (cd, info, fields->f_simm24, 0|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_RELOC)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length); 247 break; 248 case EPIPHANY_OPERAND_SIMM3 : 249 print_simm_not_reg (cd, info, fields->f_sdisp3, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX), pc, length); 250 break; 251 case EPIPHANY_OPERAND_SIMM8 : 252 print_address (cd, info, fields->f_simm8, 0|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_RELOC)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length); 253 break; 254 case EPIPHANY_OPERAND_SN : 255 print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sn, 0); 256 break; 257 case EPIPHANY_OPERAND_SN6 : 258 print_keyword (cd, info, & epiphany_cgen_opval_cr_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 259 break; 260 case EPIPHANY_OPERAND_SNDMA : 261 print_keyword (cd, info, & epiphany_cgen_opval_crdma_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 262 break; 263 case EPIPHANY_OPERAND_SNMEM : 264 print_keyword (cd, info, & epiphany_cgen_opval_crmem_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 265 break; 266 case EPIPHANY_OPERAND_SNMESH : 267 print_keyword (cd, info, & epiphany_cgen_opval_crmesh_names, fields->f_sn6, 0|(1<<CGEN_OPERAND_VIRTUAL)); 268 break; 269 case EPIPHANY_OPERAND_SWI_NUM : 270 print_uimm_not_reg (cd, info, fields->f_trap_num, 0, pc, length); 271 break; 272 case EPIPHANY_OPERAND_TRAPNUM6 : 273 print_normal (cd, info, fields->f_trap_num, 0, pc, length); 274 break; 275 276 default : 277 /* xgettext:c-format */ 278 fprintf (stderr, _("Unrecognized field %d while printing insn.\n"), 279 opindex); 280 abort (); 281 } 282 } 283 284 cgen_print_fn * const epiphany_cgen_print_handlers[] = 285 { 286 print_insn_normal, 287 }; 288 289 290 void 291 epiphany_cgen_init_dis (CGEN_CPU_DESC cd) 292 { 293 epiphany_cgen_init_opcode_table (cd); 294 epiphany_cgen_init_ibld_table (cd); 295 cd->print_handlers = & epiphany_cgen_print_handlers[0]; 296 cd->print_operand = epiphany_cgen_print_operand; 297 } 298 299 300 /* Default print handler. */ 301 302 static void 303 print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 304 void *dis_info, 305 long value, 306 unsigned int attrs, 307 bfd_vma pc ATTRIBUTE_UNUSED, 308 int length ATTRIBUTE_UNUSED) 309 { 310 disassemble_info *info = (disassemble_info *) dis_info; 311 312 /* Print the operand as directed by the attributes. */ 313 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY)) 314 ; /* nothing to do */ 315 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED)) 316 (*info->fprintf_func) (info->stream, "%ld", value); 317 else 318 (*info->fprintf_func) (info->stream, "0x%lx", value); 319 } 320 321 /* Default address handler. */ 322 323 static void 324 print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 325 void *dis_info, 326 bfd_vma value, 327 unsigned int attrs, 328 bfd_vma pc ATTRIBUTE_UNUSED, 329 int length ATTRIBUTE_UNUSED) 330 { 331 disassemble_info *info = (disassemble_info *) dis_info; 332 333 /* Print the operand as directed by the attributes. */ 334 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY)) 335 ; /* Nothing to do. */ 336 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR)) 337 (*info->print_address_func) (value, info); 338 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR)) 339 (*info->print_address_func) (value, info); 340 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED)) 341 (*info->fprintf_func) (info->stream, "%ld", (long) value); 342 else 343 (*info->fprintf_func) (info->stream, "0x%lx", (long) value); 344 } 345 346 /* Keyword print handler. */ 347 348 static void 349 print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 350 void *dis_info, 351 CGEN_KEYWORD *keyword_table, 352 long value, 353 unsigned int attrs ATTRIBUTE_UNUSED) 354 { 355 disassemble_info *info = (disassemble_info *) dis_info; 356 const CGEN_KEYWORD_ENTRY *ke; 357 358 ke = cgen_keyword_lookup_value (keyword_table, value); 359 if (ke != NULL) 360 (*info->fprintf_func) (info->stream, "%s", ke->name); 361 else 362 (*info->fprintf_func) (info->stream, "???"); 363 } 364 365 /* Default insn printer. 366 367 DIS_INFO is defined as `void *' so the disassembler needn't know anything 368 about disassemble_info. */ 369 370 static void 371 print_insn_normal (CGEN_CPU_DESC cd, 372 void *dis_info, 373 const CGEN_INSN *insn, 374 CGEN_FIELDS *fields, 375 bfd_vma pc, 376 int length) 377 { 378 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 379 disassemble_info *info = (disassemble_info *) dis_info; 380 const CGEN_SYNTAX_CHAR_TYPE *syn; 381 382 CGEN_INIT_PRINT (cd); 383 384 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn) 385 { 386 if (CGEN_SYNTAX_MNEMONIC_P (*syn)) 387 { 388 (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn)); 389 continue; 390 } 391 if (CGEN_SYNTAX_CHAR_P (*syn)) 392 { 393 (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn)); 394 continue; 395 } 396 397 /* We have an operand. */ 398 epiphany_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info, 399 fields, CGEN_INSN_ATTRS (insn), pc, length); 400 } 401 } 402 403 /* Subroutine of print_insn. Reads an insn into the given buffers and updates 404 the extract info. 405 Returns 0 if all is well, non-zero otherwise. */ 406 407 static int 408 read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 409 bfd_vma pc, 410 disassemble_info *info, 411 bfd_byte *buf, 412 int buflen, 413 CGEN_EXTRACT_INFO *ex_info, 414 unsigned long *insn_value) 415 { 416 int status = (*info->read_memory_func) (pc, buf, buflen, info); 417 418 if (status != 0) 419 { 420 (*info->memory_error_func) (status, pc, info); 421 return -1; 422 } 423 424 ex_info->dis_info = info; 425 ex_info->valid = (1 << buflen) - 1; 426 ex_info->insn_bytes = buf; 427 428 *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG); 429 return 0; 430 } 431 432 /* Utility to print an insn. 433 BUF is the base part of the insn, target byte order, BUFLEN bytes long. 434 The result is the size of the insn in bytes or zero for an unknown insn 435 or -1 if an error occurs fetching data (memory_error_func will have 436 been called). */ 437 438 static int 439 print_insn (CGEN_CPU_DESC cd, 440 bfd_vma pc, 441 disassemble_info *info, 442 bfd_byte *buf, 443 unsigned int buflen) 444 { 445 CGEN_INSN_INT insn_value; 446 const CGEN_INSN_LIST *insn_list; 447 CGEN_EXTRACT_INFO ex_info; 448 int basesize; 449 450 /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */ 451 basesize = cd->base_insn_bitsize < buflen * 8 ? 452 cd->base_insn_bitsize : buflen * 8; 453 insn_value = cgen_get_insn_value (cd, buf, basesize); 454 455 456 /* Fill in ex_info fields like read_insn would. Don't actually call 457 read_insn, since the incoming buffer is already read (and possibly 458 modified a la m32r). */ 459 ex_info.valid = (1 << buflen) - 1; 460 ex_info.dis_info = info; 461 ex_info.insn_bytes = buf; 462 463 /* The instructions are stored in hash lists. 464 Pick the first one and keep trying until we find the right one. */ 465 466 insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value); 467 while (insn_list != NULL) 468 { 469 const CGEN_INSN *insn = insn_list->insn; 470 CGEN_FIELDS fields; 471 int length; 472 unsigned long insn_value_cropped; 473 474 #ifdef CGEN_VALIDATE_INSN_SUPPORTED 475 /* Not needed as insn shouldn't be in hash lists if not supported. */ 476 /* Supported by this cpu? */ 477 if (! epiphany_cgen_insn_supported (cd, insn)) 478 { 479 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 480 continue; 481 } 482 #endif 483 484 /* Basic bit mask must be correct. */ 485 /* ??? May wish to allow target to defer this check until the extract 486 handler. */ 487 488 /* Base size may exceed this instruction's size. Extract the 489 relevant part from the buffer. */ 490 if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen && 491 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long)) 492 insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn), 493 info->endian == BFD_ENDIAN_BIG); 494 else 495 insn_value_cropped = insn_value; 496 497 if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn)) 498 == CGEN_INSN_BASE_VALUE (insn)) 499 { 500 /* Printing is handled in two passes. The first pass parses the 501 machine insn and extracts the fields. The second pass prints 502 them. */ 503 504 /* Make sure the entire insn is loaded into insn_value, if it 505 can fit. */ 506 if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) && 507 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long)) 508 { 509 unsigned long full_insn_value; 510 int rc = read_insn (cd, pc, info, buf, 511 CGEN_INSN_BITSIZE (insn) / 8, 512 & ex_info, & full_insn_value); 513 if (rc != 0) 514 return rc; 515 length = CGEN_EXTRACT_FN (cd, insn) 516 (cd, insn, &ex_info, full_insn_value, &fields, pc); 517 } 518 else 519 length = CGEN_EXTRACT_FN (cd, insn) 520 (cd, insn, &ex_info, insn_value_cropped, &fields, pc); 521 522 /* Length < 0 -> error. */ 523 if (length < 0) 524 return length; 525 if (length > 0) 526 { 527 CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length); 528 /* Length is in bits, result is in bytes. */ 529 return length / 8; 530 } 531 } 532 533 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 534 } 535 536 return 0; 537 } 538 539 /* Default value for CGEN_PRINT_INSN. 540 The result is the size of the insn in bytes or zero for an unknown insn 541 or -1 if an error occured fetching bytes. */ 542 543 #ifndef CGEN_PRINT_INSN 544 #define CGEN_PRINT_INSN default_print_insn 545 #endif 546 547 static int 548 default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 549 { 550 bfd_byte buf[CGEN_MAX_INSN_SIZE]; 551 int buflen; 552 int status; 553 554 /* Attempt to read the base part of the insn. */ 555 buflen = cd->base_insn_bitsize / 8; 556 status = (*info->read_memory_func) (pc, buf, buflen, info); 557 558 /* Try again with the minimum part, if min < base. */ 559 if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize)) 560 { 561 buflen = cd->min_insn_bitsize / 8; 562 status = (*info->read_memory_func) (pc, buf, buflen, info); 563 } 564 565 if (status != 0) 566 { 567 (*info->memory_error_func) (status, pc, info); 568 return -1; 569 } 570 571 return print_insn (cd, pc, info, buf, buflen); 572 } 573 574 /* Main entry point. 575 Print one instruction from PC on INFO->STREAM. 576 Return the size of the instruction (in bytes). */ 577 578 typedef struct cpu_desc_list 579 { 580 struct cpu_desc_list *next; 581 CGEN_BITSET *isa; 582 int mach; 583 int endian; 584 CGEN_CPU_DESC cd; 585 } cpu_desc_list; 586 587 int 588 print_insn_epiphany (bfd_vma pc, disassemble_info *info) 589 { 590 static cpu_desc_list *cd_list = 0; 591 cpu_desc_list *cl = 0; 592 static CGEN_CPU_DESC cd = 0; 593 static CGEN_BITSET *prev_isa; 594 static int prev_mach; 595 static int prev_endian; 596 int length; 597 CGEN_BITSET *isa; 598 int mach; 599 int endian = (info->endian == BFD_ENDIAN_BIG 600 ? CGEN_ENDIAN_BIG 601 : CGEN_ENDIAN_LITTLE); 602 enum bfd_architecture arch; 603 604 /* ??? gdb will set mach but leave the architecture as "unknown" */ 605 #ifndef CGEN_BFD_ARCH 606 #define CGEN_BFD_ARCH bfd_arch_epiphany 607 #endif 608 arch = info->arch; 609 if (arch == bfd_arch_unknown) 610 arch = CGEN_BFD_ARCH; 611 612 /* There's no standard way to compute the machine or isa number 613 so we leave it to the target. */ 614 #ifdef CGEN_COMPUTE_MACH 615 mach = CGEN_COMPUTE_MACH (info); 616 #else 617 mach = info->mach; 618 #endif 619 620 #ifdef CGEN_COMPUTE_ISA 621 { 622 static CGEN_BITSET *permanent_isa; 623 624 if (!permanent_isa) 625 permanent_isa = cgen_bitset_create (MAX_ISAS); 626 isa = permanent_isa; 627 cgen_bitset_clear (isa); 628 cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info)); 629 } 630 #else 631 isa = info->insn_sets; 632 #endif 633 634 /* If we've switched cpu's, try to find a handle we've used before */ 635 if (cd 636 && (cgen_bitset_compare (isa, prev_isa) != 0 637 || mach != prev_mach 638 || endian != prev_endian)) 639 { 640 cd = 0; 641 for (cl = cd_list; cl; cl = cl->next) 642 { 643 if (cgen_bitset_compare (cl->isa, isa) == 0 && 644 cl->mach == mach && 645 cl->endian == endian) 646 { 647 cd = cl->cd; 648 prev_isa = cd->isas; 649 break; 650 } 651 } 652 } 653 654 /* If we haven't initialized yet, initialize the opcode table. */ 655 if (! cd) 656 { 657 const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach); 658 const char *mach_name; 659 660 if (!arch_type) 661 abort (); 662 mach_name = arch_type->printable_name; 663 664 prev_isa = cgen_bitset_copy (isa); 665 prev_mach = mach; 666 prev_endian = endian; 667 cd = epiphany_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa, 668 CGEN_CPU_OPEN_BFDMACH, mach_name, 669 CGEN_CPU_OPEN_ENDIAN, prev_endian, 670 CGEN_CPU_OPEN_END); 671 if (!cd) 672 abort (); 673 674 /* Save this away for future reference. */ 675 cl = xmalloc (sizeof (struct cpu_desc_list)); 676 cl->cd = cd; 677 cl->isa = prev_isa; 678 cl->mach = mach; 679 cl->endian = endian; 680 cl->next = cd_list; 681 cd_list = cl; 682 683 epiphany_cgen_init_dis (cd); 684 } 685 686 /* We try to have as much common code as possible. 687 But at this point some targets need to take over. */ 688 /* ??? Some targets may need a hook elsewhere. Try to avoid this, 689 but if not possible try to move this hook elsewhere rather than 690 have two hooks. */ 691 length = CGEN_PRINT_INSN (cd, pc, info); 692 if (length > 0) 693 return length; 694 if (length < 0) 695 return -1; 696 697 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 698 return cd->default_insn_bitsize / 8; 699 } 700