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 "mep-desc.h" 36#include "mep-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/* -- dis.c */ 61 62#include "elf/mep.h" 63#include "elf-bfd.h" 64 65#define CGEN_VALIDATE_INSN_SUPPORTED 66 67static void print_tpreg (CGEN_CPU_DESC, PTR, CGEN_KEYWORD *, long, unsigned int); 68static void print_spreg (CGEN_CPU_DESC, PTR, CGEN_KEYWORD *, long, unsigned int); 69 70static void 71print_tpreg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, PTR dis_info, 72 CGEN_KEYWORD *table ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, 73 unsigned int flags ATTRIBUTE_UNUSED) 74{ 75 disassemble_info *info = (disassemble_info *) dis_info; 76 77 (*info->fprintf_func) (info->stream, "$tp"); 78} 79 80static void 81print_spreg (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, PTR dis_info, 82 CGEN_KEYWORD *table ATTRIBUTE_UNUSED, long val ATTRIBUTE_UNUSED, 83 unsigned int flags ATTRIBUTE_UNUSED) 84{ 85 disassemble_info *info = (disassemble_info *) dis_info; 86 87 (*info->fprintf_func) (info->stream, "$sp"); 88} 89 90/* begin-cop-ip-print-handlers */ 91static void 92print_ivc2_cr (CGEN_CPU_DESC, 93 void *, 94 CGEN_KEYWORD *, 95 long, 96 unsigned int) ATTRIBUTE_UNUSED; 97static void 98print_ivc2_cr (CGEN_CPU_DESC cd, 99 void *dis_info, 100 CGEN_KEYWORD *keyword_table ATTRIBUTE_UNUSED, 101 long value, 102 unsigned int attrs) 103{ 104 print_keyword (cd, dis_info, & mep_cgen_opval_h_cr_ivc2, value, attrs); 105} 106static void 107print_ivc2_ccr (CGEN_CPU_DESC, 108 void *, 109 CGEN_KEYWORD *, 110 long, 111 unsigned int) ATTRIBUTE_UNUSED; 112static void 113print_ivc2_ccr (CGEN_CPU_DESC cd, 114 void *dis_info, 115 CGEN_KEYWORD *keyword_table ATTRIBUTE_UNUSED, 116 long value, 117 unsigned int attrs) 118{ 119 print_keyword (cd, dis_info, & mep_cgen_opval_h_ccr_ivc2, value, attrs); 120} 121/* end-cop-ip-print-handlers */ 122 123/************************************************************\ 124*********************** Experimental ************************* 125\************************************************************/ 126 127#undef CGEN_PRINT_INSN 128#define CGEN_PRINT_INSN mep_print_insn 129 130static int 131mep_print_vliw_insns (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info, 132 bfd_byte *buf, int corelength, int copro1length, 133 int copro2length ATTRIBUTE_UNUSED) 134{ 135 int i; 136 int status = 0; 137 /* char insnbuf[CGEN_MAX_INSN_SIZE]; */ 138 bfd_byte insnbuf[64]; 139 140 /* If corelength > 0 then there is a core insn present. It 141 will be at the beginning of the buffer. After printing 142 the core insn, we need to print the + on the next line. */ 143 if (corelength > 0) 144 { 145 int my_status = 0; 146 147 for (i = 0; i < corelength; i++ ) 148 insnbuf[i] = buf[i]; 149 cd->isas = & MEP_CORE_ISA; 150 151 my_status = print_insn (cd, pc, info, insnbuf, corelength); 152 if (my_status != corelength) 153 { 154 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 155 my_status = corelength; 156 } 157 status += my_status; 158 159 /* Print the + to indicate that the following copro insn is */ 160 /* part of a vliw group. */ 161 if (copro1length > 0) 162 (*info->fprintf_func) (info->stream, " + "); 163 } 164 165 /* Now all that is left to be processed is the coprocessor insns 166 In vliw mode, there will always be one. Its positioning will 167 be from byte corelength to byte corelength+copro1length -1. 168 No need to check for existence. Also, the first vliw insn, 169 will, as spec'd, always be at least as long as the core insn 170 so we don't need to flush the buffer. */ 171 if (copro1length > 0) 172 { 173 int my_status = 0; 174 175 for (i = corelength; i < corelength + copro1length; i++ ) 176 insnbuf[i - corelength] = buf[i]; 177 178 switch (copro1length) 179 { 180 case 0: 181 break; 182 case 2: 183 cd->isas = & MEP_COP16_ISA; 184 break; 185 case 4: 186 cd->isas = & MEP_COP32_ISA; 187 break; 188 case 6: 189 cd->isas = & MEP_COP48_ISA; 190 break; 191 case 8: 192 cd->isas = & MEP_COP64_ISA; 193 break; 194 default: 195 /* Shouldn't be anything but 16,32,48,64. */ 196 break; 197 } 198 199 my_status = print_insn (cd, pc, info, insnbuf, copro1length); 200 201 if (my_status != copro1length) 202 { 203 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 204 my_status = copro1length; 205 } 206 status += my_status; 207 } 208 209#if 0 210 /* Now we need to process the second copro insn if it exists. We 211 have no guarantee that the second copro insn will be longer 212 than the first, so we have to flush the buffer if we are have 213 a second copro insn to process. If present, this insn will 214 be in the position from byte corelength+copro1length to byte 215 corelength+copro1length+copro2length-1 (which better equal 8 216 or else we're in big trouble. */ 217 if (copro2length > 0) 218 { 219 int my_status = 0; 220 221 for (i = 0; i < 64 ; i++) 222 insnbuf[i] = 0; 223 224 for (i = corelength + copro1length; i < 64; i++) 225 insnbuf[i - (corelength + copro1length)] = buf[i]; 226 227 switch (copro2length) 228 { 229 case 2: 230 cd->isas = 1 << ISA_EXT_COP1_16; 231 break; 232 case 4: 233 cd->isas = 1 << ISA_EXT_COP1_32; 234 break; 235 case 6: 236 cd->isas = 1 << ISA_EXT_COP1_48; 237 break; 238 case 8: 239 cd->isas = 1 << ISA_EXT_COP1_64; 240 break; 241 default: 242 /* Shouldn't be anything but 16,32,48,64. */ 243 break; 244 } 245 246 my_status = print_insn (cd, pc, info, insnbuf, copro2length); 247 248 if (my_status != copro2length) 249 { 250 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 251 my_status = copro2length; 252 } 253 254 status += my_status; 255 } 256#endif 257 258 /* Status should now be the number of bytes that were printed 259 which should be 4 for VLIW32 mode and 64 for VLIW64 mode. */ 260 261 if ((!MEP_VLIW64 && (status != 4)) || (MEP_VLIW64 && (status != 8))) 262 return -1; 263 else 264 return status; 265} 266 267/* The two functions mep_examine_vliw[32,64]_insns are used find out 268 which vliw combinaion (16 bit core with 48 bit copro, 32 bit core 269 with 32 bit copro, etc.) is present. Later on, when internally 270 parallel coprocessors are handled, only these functions should 271 need to be changed. 272 273 At this time only the following combinations are supported: 274 275 VLIW32 Mode: 276 16 bit core insn (core) and 16 bit coprocessor insn (cop1) 277 32 bit core insn (core) 278 32 bit coprocessor insn (cop1) 279 Note: As of this time, I do not believe we have enough information 280 to distinguish a 32 bit core insn from a 32 bit cop insn. Also, 281 no 16 bit coprocessor insns have been specified. 282 283 VLIW64 Mode: 284 16 bit core insn (core) and 48 bit coprocessor insn (cop1) 285 32 bit core insn (core) and 32 bit coprocessor insn (cop1) 286 64 bit coprocessor insn (cop1) 287 288 The framework for an internally parallel coprocessor is also 289 present (2nd coprocessor insn is cop2), but at this time it 290 is not used. This only appears to be valid in VLIW64 mode. */ 291 292static int 293mep_examine_vliw32_insns (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 294{ 295 int status; 296 int buflength; 297 int corebuflength; 298 int cop1buflength; 299 int cop2buflength; 300 bfd_byte buf[CGEN_MAX_INSN_SIZE]; 301 char indicator16[1]; 302 char indicatorcop32[2]; 303 304 /* At this time we're not supporting internally parallel coprocessors, 305 so cop2buflength will always be 0. */ 306 cop2buflength = 0; 307 308 /* Read in 32 bits. */ 309 buflength = 4; /* VLIW insn spans 4 bytes. */ 310 status = (*info->read_memory_func) (pc, buf, buflength, info); 311 312 if (status != 0) 313 { 314 (*info->memory_error_func) (status, pc, info); 315 return -1; 316 } 317 318 /* Put the big endian representation of the bytes to be examined 319 in the temporary buffers for examination. */ 320 321 if (info->endian == BFD_ENDIAN_BIG) 322 { 323 indicator16[0] = buf[0]; 324 indicatorcop32[0] = buf[0]; 325 indicatorcop32[1] = buf[1]; 326 } 327 else 328 { 329 indicator16[0] = buf[1]; 330 indicatorcop32[0] = buf[1]; 331 indicatorcop32[1] = buf[0]; 332 } 333 334 /* If the two high order bits are 00, 01 or 10, we have a 16 bit 335 core insn and a 48 bit copro insn. */ 336 337 if ((indicator16[0] & 0x80) && (indicator16[0] & 0x40)) 338 { 339 if ((indicatorcop32[0] & 0xf0) == 0xf0 && (indicatorcop32[1] & 0x07) == 0x07) 340 { 341 /* We have a 32 bit copro insn. */ 342 corebuflength = 0; 343 /* All 4 4ytes are one copro insn. */ 344 cop1buflength = 4; 345 } 346 else 347 { 348 /* We have a 32 bit core. */ 349 corebuflength = 4; 350 cop1buflength = 0; 351 } 352 } 353 else 354 { 355 /* We have a 16 bit core insn and a 16 bit copro insn. */ 356 corebuflength = 2; 357 cop1buflength = 2; 358 } 359 360 /* Now we have the distrubution set. Print them out. */ 361 status = mep_print_vliw_insns (cd, pc, info, buf, corebuflength, 362 cop1buflength, cop2buflength); 363 364 return status; 365} 366 367static int 368mep_examine_vliw64_insns (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 369{ 370 int status; 371 int buflength; 372 int corebuflength; 373 int cop1buflength; 374 int cop2buflength; 375 bfd_byte buf[CGEN_MAX_INSN_SIZE]; 376 char indicator16[1]; 377 char indicator64[4]; 378 379 /* At this time we're not supporting internally parallel 380 coprocessors, so cop2buflength will always be 0. */ 381 cop2buflength = 0; 382 383 /* Read in 64 bits. */ 384 buflength = 8; /* VLIW insn spans 8 bytes. */ 385 status = (*info->read_memory_func) (pc, buf, buflength, info); 386 387 if (status != 0) 388 { 389 (*info->memory_error_func) (status, pc, info); 390 return -1; 391 } 392 393 /* We have all 64 bits in the buffer now. We have to figure out 394 what combination of instruction sizes are present. The two 395 high order bits will indicate whether or not we have a 16 bit 396 core insn or not. If not, then we have to look at the 7,8th 397 bytes to tell whether we have 64 bit copro insn or a 32 bit 398 core insn with a 32 bit copro insn. Endianness will make a 399 difference here. */ 400 401 /* Put the big endian representation of the bytes to be examined 402 in the temporary buffers for examination. */ 403 404 /* indicator16[0] = buf[0]; */ 405 if (info->endian == BFD_ENDIAN_BIG) 406 { 407 indicator16[0] = buf[0]; 408 indicator64[0] = buf[0]; 409 indicator64[1] = buf[1]; 410 indicator64[2] = buf[2]; 411 indicator64[3] = buf[3]; 412 } 413 else 414 { 415 indicator16[0] = buf[1]; 416 indicator64[0] = buf[1]; 417 indicator64[1] = buf[0]; 418 indicator64[2] = buf[3]; 419 indicator64[3] = buf[2]; 420 } 421 422 /* If the two high order bits are 00, 01 or 10, we have a 16 bit 423 core insn and a 48 bit copro insn. */ 424 425 if ((indicator16[0] & 0x80) && (indicator16[0] & 0x40)) 426 { 427 if ((indicator64[0] & 0xf0) == 0xf0 && (indicator64[1] & 0x07) == 0x07 428 && ((indicator64[2] & 0xfe) != 0xf0 || (indicator64[3] & 0xf4) != 0)) 429 { 430 /* We have a 64 bit copro insn. */ 431 corebuflength = 0; 432 /* All 8 bytes are one copro insn. */ 433 cop1buflength = 8; 434 } 435 else 436 { 437 /* We have a 32 bit core insn and a 32 bit copro insn. */ 438 corebuflength = 4; 439 cop1buflength = 4; 440 } 441 } 442 else 443 { 444 /* We have a 16 bit core insn and a 48 bit copro insn. */ 445 corebuflength = 2; 446 cop1buflength = 6; 447 } 448 449 /* Now we have the distrubution set. Print them out. */ 450 status = mep_print_vliw_insns (cd, pc, info, buf, corebuflength, 451 cop1buflength, cop2buflength); 452 453 return status; 454} 455 456#ifdef MEP_IVC2_SUPPORTED 457 458static int 459print_slot_insn (CGEN_CPU_DESC cd, 460 bfd_vma pc, 461 disassemble_info *info, 462 SLOTS_ATTR slot, 463 bfd_byte *buf) 464{ 465 const CGEN_INSN_LIST *insn_list; 466 CGEN_INSN_INT insn_value; 467 CGEN_EXTRACT_INFO ex_info; 468 469 insn_value = cgen_get_insn_value (cd, buf, 32); 470 471 /* Fill in ex_info fields like read_insn would. Don't actually call 472 read_insn, since the incoming buffer is already read (and possibly 473 modified a la m32r). */ 474 ex_info.valid = (1 << 8) - 1; 475 ex_info.dis_info = info; 476 ex_info.insn_bytes = buf; 477 478 /* The instructions are stored in hash lists. 479 Pick the first one and keep trying until we find the right one. */ 480 481 insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value); 482 while (insn_list != NULL) 483 { 484 const CGEN_INSN *insn = insn_list->insn; 485 CGEN_FIELDS fields; 486 int length; 487 488 if ((CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_CONFIG) 489 && CGEN_INSN_ATTR_VALUE (insn, CGEN_INSN_CONFIG) != MEP_CONFIG) 490 || ! (CGEN_ATTR_CGEN_INSN_SLOTS_VALUE (CGEN_INSN_ATTRS (insn)) & (1 << slot))) 491 { 492 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 493 continue; 494 } 495 496 if ((insn_value & CGEN_INSN_BASE_MASK (insn)) 497 == CGEN_INSN_BASE_VALUE (insn)) 498 { 499 /* Printing is handled in two passes. The first pass parses the 500 machine insn and extracts the fields. The second pass prints 501 them. */ 502 503 length = CGEN_EXTRACT_FN (cd, insn) 504 (cd, insn, &ex_info, insn_value, &fields, pc); 505 506 /* Length < 0 -> error. */ 507 if (length < 0) 508 return length; 509 if (length > 0) 510 { 511 CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length); 512 /* Length is in bits, result is in bytes. */ 513 return length / 8; 514 } 515 } 516 517 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 518 } 519 520 if (slot == SLOTS_P0S) 521 (*info->fprintf_func) (info->stream, "*unknown-p0s*"); 522 else if (slot == SLOTS_P0) 523 (*info->fprintf_func) (info->stream, "*unknown-p0*"); 524 else if (slot == SLOTS_P1) 525 (*info->fprintf_func) (info->stream, "*unknown-p1*"); 526 else if (slot == SLOTS_C3) 527 (*info->fprintf_func) (info->stream, "*unknown-c3*"); 528 return 0; 529} 530 531static int 532mep_examine_ivc2_insns (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, bfd_vma pc ATTRIBUTE_UNUSED, disassemble_info *info ATTRIBUTE_UNUSED) 533{ 534 int status; 535 int buflength; 536 bfd_byte buf[8]; 537 bfd_byte insn[8]; 538 int e; 539 540 /* Read in 64 bits. */ 541 buflength = 8; /* VLIW insn spans 8 bytes. */ 542 status = (*info->read_memory_func) (pc, buf, buflength, info); 543 544 if (status != 0) 545 { 546 (*info->memory_error_func) (status, pc, info); 547 return -1; 548 } 549 550 if (info->endian == BFD_ENDIAN_LITTLE) 551 e = 1; 552 else 553 e = 0; 554 555 if (((unsigned char)buf[0^e] & 0xf0) < 0xc0) 556 { 557 /* <--00--><--11--><--22--><--33--><--44--><--55--><--66--><--77--> */ 558 /* V1 [-----core-----][--------p0s-------][------------p1------------] */ 559 560 print_insn (cd, pc, info, buf, 2); 561 562 insn[0^e] = 0; 563 insn[1^e] = buf[2^e]; 564 insn[2^e] = buf[3^e]; 565 insn[3^e] = buf[4^e] & 0xf0; 566 (*info->fprintf_func) (info->stream, " + "); 567 print_slot_insn (cd, pc, info, SLOTS_P0S, insn); 568 569 insn[0^e] = buf[4^e] << 4 | buf[5^e] >> 4; 570 insn[1^e] = buf[5^e] << 4 | buf[6^e] >> 4; 571 insn[2^e] = buf[6^e] << 4 | buf[7^e] >> 4; 572 insn[3^e] = buf[7^e] << 4; 573 (*info->fprintf_func) (info->stream, " + "); 574 print_slot_insn (cd, pc, info, SLOTS_P1, insn); 575 } 576 else if ((buf[0^e] & 0xf0) == 0xf0 && (buf[1^e] & 0x0f) == 0x07) 577 { 578 /* <--00--><--11--><--22--><--33--><--44--><--55--><--66--><--77--> */ 579 /* V3 1111[--p0--]0111[--------p0--------][------------p1------------] */ 580 /* 00000000111111112222222233333333 */ 581 582 insn[0^e] = buf[0^e] << 4 | buf[1^e] >> 4; 583 insn[1^e] = buf[2^e]; 584 insn[2^e] = buf[3^e]; 585 insn[3^e] = buf[4^e] & 0xf0; 586 print_slot_insn (cd, pc, info, SLOTS_P0, insn); 587 588 insn[0^e] = buf[4^e] << 4 | buf[5^e] >> 4; 589 insn[1^e] = buf[5^e] << 4 | buf[6^e] >> 4; 590 insn[2^e] = buf[6^e] << 4 | buf[7^e] >> 4; 591 insn[3^e] = buf[7^e] << 4; 592 (*info->fprintf_func) (info->stream, " + "); 593 print_slot_insn (cd, pc, info, SLOTS_P1, insn); 594 } 595 else 596 { 597 /* <--00--><--11--><--22--><--33--><--44--><--55--><--66--><--77--> */ 598 /* V2 [-------------core-------------]xxxx[------------p1------------] */ 599 print_insn (cd, pc, info, buf, 4); 600 601 insn[0^e] = buf[4^e] << 4 | buf[5^e] >> 4; 602 insn[1^e] = buf[5^e] << 4 | buf[6^e] >> 4; 603 insn[2^e] = buf[6^e] << 4 | buf[7^e] >> 4; 604 insn[3^e] = buf[7^e] << 4; 605 (*info->fprintf_func) (info->stream, " + "); 606 print_slot_insn (cd, pc, info, SLOTS_P1, insn); 607 } 608 609 return 8; 610} 611 612#endif /* MEP_IVC2_SUPPORTED */ 613 614/* This is a hack. SID calls this to update the disassembler as the 615 CPU changes modes. */ 616static int mep_ivc2_disassemble_p = 0; 617static int mep_ivc2_vliw_disassemble_p = 0; 618 619void 620mep_print_insn_set_ivc2_mode (int ivc2_p, int vliw_p, int cfg_idx); 621void 622mep_print_insn_set_ivc2_mode (int ivc2_p, int vliw_p, int cfg_idx) 623{ 624 mep_ivc2_disassemble_p = ivc2_p; 625 mep_ivc2_vliw_disassemble_p = vliw_p; 626 mep_config_index = cfg_idx; 627} 628 629static int 630mep_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 631{ 632 int status; 633 int cop_type; 634 int ivc2 = 0; 635 static CGEN_ATTR_VALUE_BITSET_TYPE *ivc2_core_isa = NULL; 636 637 if (ivc2_core_isa == NULL) 638 { 639 /* IVC2 has some core-only coprocessor instructions. We 640 use COP32 to flag those, and COP64 for the VLIW ones, 641 since they have the same names. */ 642 ivc2_core_isa = cgen_bitset_create (MAX_ISAS); 643 } 644 645 /* Extract and adapt to configuration number, if available. */ 646 if (info->section && info->section->owner) 647 { 648 bfd *abfd = info->section->owner; 649 mep_config_index = abfd->tdata.elf_obj_data->elf_header->e_flags & EF_MEP_INDEX_MASK; 650 /* This instantly redefines MEP_CONFIG, MEP_OMASK, .... MEP_VLIW64 */ 651 652 cop_type = abfd->tdata.elf_obj_data->elf_header->e_flags & EF_MEP_COP_MASK; 653 if (cop_type == EF_MEP_COP_IVC2) 654 ivc2 = 1; 655 } 656 657 /* Picking the right ISA bitmask for the current context is tricky. */ 658 if (info->section) 659 { 660 if (info->section->flags & SEC_MEP_VLIW) 661 { 662#ifdef MEP_IVC2_SUPPORTED 663 if (ivc2) 664 { 665 /* ivc2 has its own way of selecting its functions. */ 666 cd->isas = & MEP_CORE_ISA; 667 status = mep_examine_ivc2_insns (cd, pc, info); 668 } 669 else 670#endif 671 /* Are we in 32 or 64 bit vliw mode? */ 672 if (MEP_VLIW64) 673 status = mep_examine_vliw64_insns (cd, pc, info); 674 else 675 status = mep_examine_vliw32_insns (cd, pc, info); 676 /* Both the above branches set their own isa bitmasks. */ 677 } 678 else 679 { 680 if (ivc2) 681 { 682 cgen_bitset_clear (ivc2_core_isa); 683 cgen_bitset_union (ivc2_core_isa, &MEP_CORE_ISA, ivc2_core_isa); 684 cgen_bitset_union (ivc2_core_isa, &MEP_COP32_ISA, ivc2_core_isa); 685 cd->isas = ivc2_core_isa; 686 } 687 else 688 cd->isas = & MEP_CORE_ISA; 689 status = default_print_insn (cd, pc, info); 690 } 691 } 692 else /* sid or gdb */ 693 { 694#ifdef MEP_IVC2_SUPPORTED 695 if (mep_ivc2_disassemble_p) 696 { 697 if (mep_ivc2_vliw_disassemble_p) 698 { 699 cd->isas = & MEP_CORE_ISA; 700 status = mep_examine_ivc2_insns (cd, pc, info); 701 return status; 702 } 703 else 704 { 705 if (ivc2) 706 cd->isas = ivc2_core_isa; 707 } 708 } 709#endif 710 711 status = default_print_insn (cd, pc, info); 712 } 713 714 return status; 715} 716 717 718/* -- opc.c */ 719 720void mep_cgen_print_operand 721 (CGEN_CPU_DESC, int, PTR, CGEN_FIELDS *, void const *, bfd_vma, int); 722 723/* Main entry point for printing operands. 724 XINFO is a `void *' and not a `disassemble_info *' to not put a requirement 725 of dis-asm.h on cgen.h. 726 727 This function is basically just a big switch statement. Earlier versions 728 used tables to look up the function to use, but 729 - if the table contains both assembler and disassembler functions then 730 the disassembler contains much of the assembler and vice-versa, 731 - there's a lot of inlining possibilities as things grow, 732 - using a switch statement avoids the function call overhead. 733 734 This function could be moved into `print_insn_normal', but keeping it 735 separate makes clear the interface between `print_insn_normal' and each of 736 the handlers. */ 737 738void 739mep_cgen_print_operand (CGEN_CPU_DESC cd, 740 int opindex, 741 void * xinfo, 742 CGEN_FIELDS *fields, 743 void const *attrs ATTRIBUTE_UNUSED, 744 bfd_vma pc, 745 int length) 746{ 747 disassemble_info *info = (disassemble_info *) xinfo; 748 749 switch (opindex) 750 { 751 case MEP_OPERAND_ADDR24A4 : 752 print_normal (cd, info, fields->f_24u8a4n, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 753 break; 754 case MEP_OPERAND_C5RMUIMM20 : 755 print_normal (cd, info, fields->f_c5_rmuimm20, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 756 break; 757 case MEP_OPERAND_C5RNMUIMM24 : 758 print_normal (cd, info, fields->f_c5_rnmuimm24, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 759 break; 760 case MEP_OPERAND_CALLNUM : 761 print_normal (cd, info, fields->f_callnum, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 762 break; 763 case MEP_OPERAND_CCCC : 764 print_normal (cd, info, fields->f_rm, 0, pc, length); 765 break; 766 case MEP_OPERAND_CCRN : 767 print_keyword (cd, info, & mep_cgen_opval_h_ccr, fields->f_ccrn, 0|(1<<CGEN_OPERAND_VIRTUAL)); 768 break; 769 case MEP_OPERAND_CDISP10 : 770 print_normal (cd, info, fields->f_cdisp10, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 771 break; 772 case MEP_OPERAND_CDISP10A2 : 773 print_normal (cd, info, fields->f_cdisp10, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 774 break; 775 case MEP_OPERAND_CDISP10A4 : 776 print_normal (cd, info, fields->f_cdisp10, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 777 break; 778 case MEP_OPERAND_CDISP10A8 : 779 print_normal (cd, info, fields->f_cdisp10, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 780 break; 781 case MEP_OPERAND_CDISP12 : 782 print_normal (cd, info, fields->f_12s20, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 783 break; 784 case MEP_OPERAND_CIMM4 : 785 print_normal (cd, info, fields->f_rn, 0, pc, length); 786 break; 787 case MEP_OPERAND_CIMM5 : 788 print_normal (cd, info, fields->f_5u24, 0, pc, length); 789 break; 790 case MEP_OPERAND_CODE16 : 791 print_normal (cd, info, fields->f_16u16, 0, pc, length); 792 break; 793 case MEP_OPERAND_CODE24 : 794 print_normal (cd, info, fields->f_24u4n, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 795 break; 796 case MEP_OPERAND_CP_FLAG : 797 print_keyword (cd, info, & mep_cgen_opval_h_ccr, 0, 0); 798 break; 799 case MEP_OPERAND_CRN : 800 print_keyword (cd, info, & mep_cgen_opval_h_cr, fields->f_crn, 0); 801 break; 802 case MEP_OPERAND_CRN64 : 803 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_crn, 0); 804 break; 805 case MEP_OPERAND_CRNX : 806 print_keyword (cd, info, & mep_cgen_opval_h_cr, fields->f_crnx, 0|(1<<CGEN_OPERAND_VIRTUAL)); 807 break; 808 case MEP_OPERAND_CRNX64 : 809 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_crnx, 0|(1<<CGEN_OPERAND_VIRTUAL)); 810 break; 811 case MEP_OPERAND_CROC : 812 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_5u7, 0); 813 break; 814 case MEP_OPERAND_CROP : 815 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_5u23, 0); 816 break; 817 case MEP_OPERAND_CRPC : 818 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_5u26, 0); 819 break; 820 case MEP_OPERAND_CRPP : 821 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_5u18, 0); 822 break; 823 case MEP_OPERAND_CRQC : 824 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_5u21, 0); 825 break; 826 case MEP_OPERAND_CRQP : 827 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_5u13, 0); 828 break; 829 case MEP_OPERAND_CSRN : 830 print_keyword (cd, info, & mep_cgen_opval_h_csr, fields->f_csrn, 0|(1<<CGEN_OPERAND_VIRTUAL)); 831 break; 832 case MEP_OPERAND_CSRN_IDX : 833 print_normal (cd, info, fields->f_csrn, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 834 break; 835 case MEP_OPERAND_DBG : 836 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 837 break; 838 case MEP_OPERAND_DEPC : 839 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 840 break; 841 case MEP_OPERAND_EPC : 842 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 843 break; 844 case MEP_OPERAND_EXC : 845 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 846 break; 847 case MEP_OPERAND_HI : 848 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 849 break; 850 case MEP_OPERAND_IMM16P0 : 851 print_normal (cd, info, fields->f_ivc2_imm16p0, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 852 break; 853 case MEP_OPERAND_IMM3P12 : 854 print_normal (cd, info, fields->f_ivc2_3u12, 0, pc, length); 855 break; 856 case MEP_OPERAND_IMM3P25 : 857 print_normal (cd, info, fields->f_ivc2_3u25, 0, pc, length); 858 break; 859 case MEP_OPERAND_IMM3P4 : 860 print_normal (cd, info, fields->f_ivc2_3u4, 0, pc, length); 861 break; 862 case MEP_OPERAND_IMM3P5 : 863 print_normal (cd, info, fields->f_ivc2_3u5, 0, pc, length); 864 break; 865 case MEP_OPERAND_IMM3P9 : 866 print_normal (cd, info, fields->f_ivc2_3u9, 0, pc, length); 867 break; 868 case MEP_OPERAND_IMM4P10 : 869 print_normal (cd, info, fields->f_ivc2_4u10, 0, pc, length); 870 break; 871 case MEP_OPERAND_IMM4P4 : 872 print_normal (cd, info, fields->f_ivc2_4u4, 0, pc, length); 873 break; 874 case MEP_OPERAND_IMM4P8 : 875 print_normal (cd, info, fields->f_ivc2_4u8, 0, pc, length); 876 break; 877 case MEP_OPERAND_IMM5P23 : 878 print_normal (cd, info, fields->f_ivc2_5u23, 0, pc, length); 879 break; 880 case MEP_OPERAND_IMM5P3 : 881 print_normal (cd, info, fields->f_ivc2_5u3, 0, pc, length); 882 break; 883 case MEP_OPERAND_IMM5P7 : 884 print_normal (cd, info, fields->f_ivc2_5u7, 0, pc, length); 885 break; 886 case MEP_OPERAND_IMM5P8 : 887 print_normal (cd, info, fields->f_ivc2_5u8, 0, pc, length); 888 break; 889 case MEP_OPERAND_IMM6P2 : 890 print_normal (cd, info, fields->f_ivc2_6u2, 0, pc, length); 891 break; 892 case MEP_OPERAND_IMM6P6 : 893 print_normal (cd, info, fields->f_ivc2_6u6, 0, pc, length); 894 break; 895 case MEP_OPERAND_IMM8P0 : 896 print_normal (cd, info, fields->f_ivc2_8u0, 0, pc, length); 897 break; 898 case MEP_OPERAND_IMM8P20 : 899 print_normal (cd, info, fields->f_ivc2_8u20, 0, pc, length); 900 break; 901 case MEP_OPERAND_IMM8P4 : 902 print_normal (cd, info, fields->f_ivc2_8u4, 0, pc, length); 903 break; 904 case MEP_OPERAND_IVC_X_0_2 : 905 print_normal (cd, info, fields->f_ivc2_2u0, 0, pc, length); 906 break; 907 case MEP_OPERAND_IVC_X_0_3 : 908 print_normal (cd, info, fields->f_ivc2_3u0, 0, pc, length); 909 break; 910 case MEP_OPERAND_IVC_X_0_4 : 911 print_normal (cd, info, fields->f_ivc2_4u0, 0, pc, length); 912 break; 913 case MEP_OPERAND_IVC_X_0_5 : 914 print_normal (cd, info, fields->f_ivc2_5u0, 0, pc, length); 915 break; 916 case MEP_OPERAND_IVC_X_6_1 : 917 print_normal (cd, info, fields->f_ivc2_1u6, 0, pc, length); 918 break; 919 case MEP_OPERAND_IVC_X_6_2 : 920 print_normal (cd, info, fields->f_ivc2_2u6, 0, pc, length); 921 break; 922 case MEP_OPERAND_IVC_X_6_3 : 923 print_normal (cd, info, fields->f_ivc2_3u6, 0, pc, length); 924 break; 925 case MEP_OPERAND_IVC2_ACC0_0 : 926 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 927 break; 928 case MEP_OPERAND_IVC2_ACC0_1 : 929 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 930 break; 931 case MEP_OPERAND_IVC2_ACC0_2 : 932 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 933 break; 934 case MEP_OPERAND_IVC2_ACC0_3 : 935 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 936 break; 937 case MEP_OPERAND_IVC2_ACC0_4 : 938 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 939 break; 940 case MEP_OPERAND_IVC2_ACC0_5 : 941 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 942 break; 943 case MEP_OPERAND_IVC2_ACC0_6 : 944 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 945 break; 946 case MEP_OPERAND_IVC2_ACC0_7 : 947 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 948 break; 949 case MEP_OPERAND_IVC2_ACC1_0 : 950 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 951 break; 952 case MEP_OPERAND_IVC2_ACC1_1 : 953 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 954 break; 955 case MEP_OPERAND_IVC2_ACC1_2 : 956 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 957 break; 958 case MEP_OPERAND_IVC2_ACC1_3 : 959 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 960 break; 961 case MEP_OPERAND_IVC2_ACC1_4 : 962 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 963 break; 964 case MEP_OPERAND_IVC2_ACC1_5 : 965 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 966 break; 967 case MEP_OPERAND_IVC2_ACC1_6 : 968 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 969 break; 970 case MEP_OPERAND_IVC2_ACC1_7 : 971 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 972 break; 973 case MEP_OPERAND_IVC2_CC : 974 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 975 break; 976 case MEP_OPERAND_IVC2_COFA0 : 977 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 978 break; 979 case MEP_OPERAND_IVC2_COFA1 : 980 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 981 break; 982 case MEP_OPERAND_IVC2_COFR0 : 983 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 984 break; 985 case MEP_OPERAND_IVC2_COFR1 : 986 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 987 break; 988 case MEP_OPERAND_IVC2_CSAR0 : 989 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 990 break; 991 case MEP_OPERAND_IVC2_CSAR1 : 992 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, 0, 0); 993 break; 994 case MEP_OPERAND_IVC2C3CCRN : 995 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, fields->f_ivc2_ccrn_c3, 0|(1<<CGEN_OPERAND_VIRTUAL)); 996 break; 997 case MEP_OPERAND_IVC2CCRN : 998 print_keyword (cd, info, & mep_cgen_opval_h_ccr_ivc2, fields->f_ivc2_ccrn, 0|(1<<CGEN_OPERAND_VIRTUAL)); 999 break; 1000 case MEP_OPERAND_IVC2CRN : 1001 print_keyword (cd, info, & mep_cgen_opval_h_cr64, fields->f_ivc2_crnx, 0|(1<<CGEN_OPERAND_VIRTUAL)); 1002 break; 1003 case MEP_OPERAND_IVC2RM : 1004 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_ivc2_crm, 0); 1005 break; 1006 case MEP_OPERAND_LO : 1007 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1008 break; 1009 case MEP_OPERAND_LP : 1010 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1011 break; 1012 case MEP_OPERAND_MB0 : 1013 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1014 break; 1015 case MEP_OPERAND_MB1 : 1016 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1017 break; 1018 case MEP_OPERAND_ME0 : 1019 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1020 break; 1021 case MEP_OPERAND_ME1 : 1022 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1023 break; 1024 case MEP_OPERAND_NPC : 1025 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1026 break; 1027 case MEP_OPERAND_OPT : 1028 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1029 break; 1030 case MEP_OPERAND_PCABS24A2 : 1031 print_address (cd, info, fields->f_24u5a2n, 0|(1<<CGEN_OPERAND_ABS_ADDR)|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 1032 break; 1033 case MEP_OPERAND_PCREL12A2 : 1034 print_address (cd, info, fields->f_12s4a2, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length); 1035 break; 1036 case MEP_OPERAND_PCREL17A2 : 1037 print_address (cd, info, fields->f_17s16a2, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length); 1038 break; 1039 case MEP_OPERAND_PCREL24A2 : 1040 print_address (cd, info, fields->f_24s5a2n, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_PCREL_ADDR)|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 1041 break; 1042 case MEP_OPERAND_PCREL8A2 : 1043 print_address (cd, info, fields->f_8s8a2, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELAX)|(1<<CGEN_OPERAND_PCREL_ADDR), pc, length); 1044 break; 1045 case MEP_OPERAND_PSW : 1046 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1047 break; 1048 case MEP_OPERAND_R0 : 1049 print_keyword (cd, info, & mep_cgen_opval_h_gpr, 0, 0); 1050 break; 1051 case MEP_OPERAND_R1 : 1052 print_keyword (cd, info, & mep_cgen_opval_h_gpr, 0, 0); 1053 break; 1054 case MEP_OPERAND_RL : 1055 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rl, 0); 1056 break; 1057 case MEP_OPERAND_RL5 : 1058 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rl5, 0); 1059 break; 1060 case MEP_OPERAND_RM : 1061 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rm, 0); 1062 break; 1063 case MEP_OPERAND_RMA : 1064 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rm, 0); 1065 break; 1066 case MEP_OPERAND_RN : 1067 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1068 break; 1069 case MEP_OPERAND_RN3 : 1070 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1071 break; 1072 case MEP_OPERAND_RN3C : 1073 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1074 break; 1075 case MEP_OPERAND_RN3L : 1076 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1077 break; 1078 case MEP_OPERAND_RN3S : 1079 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1080 break; 1081 case MEP_OPERAND_RN3UC : 1082 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1083 break; 1084 case MEP_OPERAND_RN3UL : 1085 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1086 break; 1087 case MEP_OPERAND_RN3US : 1088 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn3, 0); 1089 break; 1090 case MEP_OPERAND_RNC : 1091 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1092 break; 1093 case MEP_OPERAND_RNL : 1094 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1095 break; 1096 case MEP_OPERAND_RNS : 1097 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1098 break; 1099 case MEP_OPERAND_RNUC : 1100 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1101 break; 1102 case MEP_OPERAND_RNUL : 1103 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1104 break; 1105 case MEP_OPERAND_RNUS : 1106 print_keyword (cd, info, & mep_cgen_opval_h_gpr, fields->f_rn, 0); 1107 break; 1108 case MEP_OPERAND_SAR : 1109 print_keyword (cd, info, & mep_cgen_opval_h_csr, 0, 0); 1110 break; 1111 case MEP_OPERAND_SDISP16 : 1112 print_normal (cd, info, fields->f_16s16, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1113 break; 1114 case MEP_OPERAND_SIMM16 : 1115 print_normal (cd, info, fields->f_16s16, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1116 break; 1117 case MEP_OPERAND_SIMM16P0 : 1118 print_normal (cd, info, fields->f_ivc2_simm16p0, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 1119 break; 1120 case MEP_OPERAND_SIMM6 : 1121 print_normal (cd, info, fields->f_6s8, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1122 break; 1123 case MEP_OPERAND_SIMM8 : 1124 print_normal (cd, info, fields->f_8s8, 0|(1<<CGEN_OPERAND_SIGNED)|(1<<CGEN_OPERAND_RELOC_IMPLIES_OVERFLOW), pc, length); 1125 break; 1126 case MEP_OPERAND_SIMM8P0 : 1127 print_normal (cd, info, fields->f_ivc2_8s0, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1128 break; 1129 case MEP_OPERAND_SIMM8P20 : 1130 print_normal (cd, info, fields->f_ivc2_8s20, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1131 break; 1132 case MEP_OPERAND_SIMM8P4 : 1133 print_normal (cd, info, fields->f_ivc2_8s4, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1134 break; 1135 case MEP_OPERAND_SP : 1136 print_keyword (cd, info, & mep_cgen_opval_h_gpr, 0, 0); 1137 break; 1138 case MEP_OPERAND_SPR : 1139 print_spreg (cd, info, & mep_cgen_opval_h_gpr, 0, 0); 1140 break; 1141 case MEP_OPERAND_TP : 1142 print_keyword (cd, info, & mep_cgen_opval_h_gpr, 0, 0); 1143 break; 1144 case MEP_OPERAND_TPR : 1145 print_tpreg (cd, info, & mep_cgen_opval_h_gpr, 0, 0); 1146 break; 1147 case MEP_OPERAND_UDISP2 : 1148 print_normal (cd, info, fields->f_2u6, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1149 break; 1150 case MEP_OPERAND_UDISP7 : 1151 print_normal (cd, info, fields->f_7u9, 0, pc, length); 1152 break; 1153 case MEP_OPERAND_UDISP7A2 : 1154 print_normal (cd, info, fields->f_7u9a2, 0, pc, length); 1155 break; 1156 case MEP_OPERAND_UDISP7A4 : 1157 print_normal (cd, info, fields->f_7u9a4, 0, pc, length); 1158 break; 1159 case MEP_OPERAND_UIMM16 : 1160 print_normal (cd, info, fields->f_16u16, 0, pc, length); 1161 break; 1162 case MEP_OPERAND_UIMM2 : 1163 print_normal (cd, info, fields->f_2u10, 0, pc, length); 1164 break; 1165 case MEP_OPERAND_UIMM24 : 1166 print_normal (cd, info, fields->f_24u8n, 0|(1<<CGEN_OPERAND_VIRTUAL), pc, length); 1167 break; 1168 case MEP_OPERAND_UIMM3 : 1169 print_normal (cd, info, fields->f_3u5, 0, pc, length); 1170 break; 1171 case MEP_OPERAND_UIMM4 : 1172 print_normal (cd, info, fields->f_4u8, 0, pc, length); 1173 break; 1174 case MEP_OPERAND_UIMM5 : 1175 print_normal (cd, info, fields->f_5u8, 0, pc, length); 1176 break; 1177 case MEP_OPERAND_UIMM7A4 : 1178 print_normal (cd, info, fields->f_7u9a4, 0, pc, length); 1179 break; 1180 case MEP_OPERAND_ZERO : 1181 print_normal (cd, info, 0, 0|(1<<CGEN_OPERAND_SIGNED), pc, length); 1182 break; 1183 1184 default : 1185 /* xgettext:c-format */ 1186 fprintf (stderr, _("Unrecognized field %d while printing insn.\n"), 1187 opindex); 1188 abort (); 1189 } 1190} 1191 1192cgen_print_fn * const mep_cgen_print_handlers[] = 1193{ 1194 print_insn_normal, 1195}; 1196 1197 1198void 1199mep_cgen_init_dis (CGEN_CPU_DESC cd) 1200{ 1201 mep_cgen_init_opcode_table (cd); 1202 mep_cgen_init_ibld_table (cd); 1203 cd->print_handlers = & mep_cgen_print_handlers[0]; 1204 cd->print_operand = mep_cgen_print_operand; 1205} 1206 1207 1208/* Default print handler. */ 1209 1210static void 1211print_normal (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 1212 void *dis_info, 1213 long value, 1214 unsigned int attrs, 1215 bfd_vma pc ATTRIBUTE_UNUSED, 1216 int length ATTRIBUTE_UNUSED) 1217{ 1218 disassemble_info *info = (disassemble_info *) dis_info; 1219 1220 /* Print the operand as directed by the attributes. */ 1221 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY)) 1222 ; /* nothing to do */ 1223 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED)) 1224 (*info->fprintf_func) (info->stream, "%ld", value); 1225 else 1226 (*info->fprintf_func) (info->stream, "0x%lx", value); 1227} 1228 1229/* Default address handler. */ 1230 1231static void 1232print_address (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 1233 void *dis_info, 1234 bfd_vma value, 1235 unsigned int attrs, 1236 bfd_vma pc ATTRIBUTE_UNUSED, 1237 int length ATTRIBUTE_UNUSED) 1238{ 1239 disassemble_info *info = (disassemble_info *) dis_info; 1240 1241 /* Print the operand as directed by the attributes. */ 1242 if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SEM_ONLY)) 1243 ; /* Nothing to do. */ 1244 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_PCREL_ADDR)) 1245 (*info->print_address_func) (value, info); 1246 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_ABS_ADDR)) 1247 (*info->print_address_func) (value, info); 1248 else if (CGEN_BOOL_ATTR (attrs, CGEN_OPERAND_SIGNED)) 1249 (*info->fprintf_func) (info->stream, "%ld", (long) value); 1250 else 1251 (*info->fprintf_func) (info->stream, "0x%lx", (long) value); 1252} 1253 1254/* Keyword print handler. */ 1255 1256static void 1257print_keyword (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 1258 void *dis_info, 1259 CGEN_KEYWORD *keyword_table, 1260 long value, 1261 unsigned int attrs ATTRIBUTE_UNUSED) 1262{ 1263 disassemble_info *info = (disassemble_info *) dis_info; 1264 const CGEN_KEYWORD_ENTRY *ke; 1265 1266 ke = cgen_keyword_lookup_value (keyword_table, value); 1267 if (ke != NULL) 1268 (*info->fprintf_func) (info->stream, "%s", ke->name); 1269 else 1270 (*info->fprintf_func) (info->stream, "???"); 1271} 1272 1273/* Default insn printer. 1274 1275 DIS_INFO is defined as `void *' so the disassembler needn't know anything 1276 about disassemble_info. */ 1277 1278static void 1279print_insn_normal (CGEN_CPU_DESC cd, 1280 void *dis_info, 1281 const CGEN_INSN *insn, 1282 CGEN_FIELDS *fields, 1283 bfd_vma pc, 1284 int length) 1285{ 1286 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 1287 disassemble_info *info = (disassemble_info *) dis_info; 1288 const CGEN_SYNTAX_CHAR_TYPE *syn; 1289 1290 CGEN_INIT_PRINT (cd); 1291 1292 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn) 1293 { 1294 if (CGEN_SYNTAX_MNEMONIC_P (*syn)) 1295 { 1296 (*info->fprintf_func) (info->stream, "%s", CGEN_INSN_MNEMONIC (insn)); 1297 continue; 1298 } 1299 if (CGEN_SYNTAX_CHAR_P (*syn)) 1300 { 1301 (*info->fprintf_func) (info->stream, "%c", CGEN_SYNTAX_CHAR (*syn)); 1302 continue; 1303 } 1304 1305 /* We have an operand. */ 1306 mep_cgen_print_operand (cd, CGEN_SYNTAX_FIELD (*syn), info, 1307 fields, CGEN_INSN_ATTRS (insn), pc, length); 1308 } 1309} 1310 1311/* Subroutine of print_insn. Reads an insn into the given buffers and updates 1312 the extract info. 1313 Returns 0 if all is well, non-zero otherwise. */ 1314 1315static int 1316read_insn (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 1317 bfd_vma pc, 1318 disassemble_info *info, 1319 bfd_byte *buf, 1320 int buflen, 1321 CGEN_EXTRACT_INFO *ex_info, 1322 unsigned long *insn_value) 1323{ 1324 int status = (*info->read_memory_func) (pc, buf, buflen, info); 1325 1326 if (status != 0) 1327 { 1328 (*info->memory_error_func) (status, pc, info); 1329 return -1; 1330 } 1331 1332 ex_info->dis_info = info; 1333 ex_info->valid = (1 << buflen) - 1; 1334 ex_info->insn_bytes = buf; 1335 1336 *insn_value = bfd_get_bits (buf, buflen * 8, info->endian == BFD_ENDIAN_BIG); 1337 return 0; 1338} 1339 1340/* Utility to print an insn. 1341 BUF is the base part of the insn, target byte order, BUFLEN bytes long. 1342 The result is the size of the insn in bytes or zero for an unknown insn 1343 or -1 if an error occurs fetching data (memory_error_func will have 1344 been called). */ 1345 1346static int 1347print_insn (CGEN_CPU_DESC cd, 1348 bfd_vma pc, 1349 disassemble_info *info, 1350 bfd_byte *buf, 1351 unsigned int buflen) 1352{ 1353 CGEN_INSN_INT insn_value; 1354 const CGEN_INSN_LIST *insn_list; 1355 CGEN_EXTRACT_INFO ex_info; 1356 int basesize; 1357 1358 /* Extract base part of instruction, just in case CGEN_DIS_* uses it. */ 1359 basesize = cd->base_insn_bitsize < buflen * 8 ? 1360 cd->base_insn_bitsize : buflen * 8; 1361 insn_value = cgen_get_insn_value (cd, buf, basesize); 1362 1363 1364 /* Fill in ex_info fields like read_insn would. Don't actually call 1365 read_insn, since the incoming buffer is already read (and possibly 1366 modified a la m32r). */ 1367 ex_info.valid = (1 << buflen) - 1; 1368 ex_info.dis_info = info; 1369 ex_info.insn_bytes = buf; 1370 1371 /* The instructions are stored in hash lists. 1372 Pick the first one and keep trying until we find the right one. */ 1373 1374 insn_list = CGEN_DIS_LOOKUP_INSN (cd, (char *) buf, insn_value); 1375 while (insn_list != NULL) 1376 { 1377 const CGEN_INSN *insn = insn_list->insn; 1378 CGEN_FIELDS fields; 1379 int length; 1380 unsigned long insn_value_cropped; 1381 1382#ifdef CGEN_VALIDATE_INSN_SUPPORTED 1383 /* Not needed as insn shouldn't be in hash lists if not supported. */ 1384 /* Supported by this cpu? */ 1385 if (! mep_cgen_insn_supported (cd, insn)) 1386 { 1387 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 1388 continue; 1389 } 1390#endif 1391 1392 /* Basic bit mask must be correct. */ 1393 /* ??? May wish to allow target to defer this check until the extract 1394 handler. */ 1395 1396 /* Base size may exceed this instruction's size. Extract the 1397 relevant part from the buffer. */ 1398 if ((unsigned) (CGEN_INSN_BITSIZE (insn) / 8) < buflen && 1399 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long)) 1400 insn_value_cropped = bfd_get_bits (buf, CGEN_INSN_BITSIZE (insn), 1401 info->endian == BFD_ENDIAN_BIG); 1402 else 1403 insn_value_cropped = insn_value; 1404 1405 if ((insn_value_cropped & CGEN_INSN_BASE_MASK (insn)) 1406 == CGEN_INSN_BASE_VALUE (insn)) 1407 { 1408 /* Printing is handled in two passes. The first pass parses the 1409 machine insn and extracts the fields. The second pass prints 1410 them. */ 1411 1412 /* Make sure the entire insn is loaded into insn_value, if it 1413 can fit. */ 1414 if (((unsigned) CGEN_INSN_BITSIZE (insn) > cd->base_insn_bitsize) && 1415 (unsigned) (CGEN_INSN_BITSIZE (insn) / 8) <= sizeof (unsigned long)) 1416 { 1417 unsigned long full_insn_value; 1418 int rc = read_insn (cd, pc, info, buf, 1419 CGEN_INSN_BITSIZE (insn) / 8, 1420 & ex_info, & full_insn_value); 1421 if (rc != 0) 1422 return rc; 1423 length = CGEN_EXTRACT_FN (cd, insn) 1424 (cd, insn, &ex_info, full_insn_value, &fields, pc); 1425 } 1426 else 1427 length = CGEN_EXTRACT_FN (cd, insn) 1428 (cd, insn, &ex_info, insn_value_cropped, &fields, pc); 1429 1430 /* Length < 0 -> error. */ 1431 if (length < 0) 1432 return length; 1433 if (length > 0) 1434 { 1435 CGEN_PRINT_FN (cd, insn) (cd, info, insn, &fields, pc, length); 1436 /* Length is in bits, result is in bytes. */ 1437 return length / 8; 1438 } 1439 } 1440 1441 insn_list = CGEN_DIS_NEXT_INSN (insn_list); 1442 } 1443 1444 return 0; 1445} 1446 1447/* Default value for CGEN_PRINT_INSN. 1448 The result is the size of the insn in bytes or zero for an unknown insn 1449 or -1 if an error occured fetching bytes. */ 1450 1451#ifndef CGEN_PRINT_INSN 1452#define CGEN_PRINT_INSN default_print_insn 1453#endif 1454 1455static int 1456default_print_insn (CGEN_CPU_DESC cd, bfd_vma pc, disassemble_info *info) 1457{ 1458 bfd_byte buf[CGEN_MAX_INSN_SIZE]; 1459 int buflen; 1460 int status; 1461 1462 /* Attempt to read the base part of the insn. */ 1463 buflen = cd->base_insn_bitsize / 8; 1464 status = (*info->read_memory_func) (pc, buf, buflen, info); 1465 1466 /* Try again with the minimum part, if min < base. */ 1467 if (status != 0 && (cd->min_insn_bitsize < cd->base_insn_bitsize)) 1468 { 1469 buflen = cd->min_insn_bitsize / 8; 1470 status = (*info->read_memory_func) (pc, buf, buflen, info); 1471 } 1472 1473 if (status != 0) 1474 { 1475 (*info->memory_error_func) (status, pc, info); 1476 return -1; 1477 } 1478 1479 return print_insn (cd, pc, info, buf, buflen); 1480} 1481 1482/* Main entry point. 1483 Print one instruction from PC on INFO->STREAM. 1484 Return the size of the instruction (in bytes). */ 1485 1486typedef struct cpu_desc_list 1487{ 1488 struct cpu_desc_list *next; 1489 CGEN_BITSET *isa; 1490 int mach; 1491 int endian; 1492 CGEN_CPU_DESC cd; 1493} cpu_desc_list; 1494 1495int 1496print_insn_mep (bfd_vma pc, disassemble_info *info) 1497{ 1498 static cpu_desc_list *cd_list = 0; 1499 cpu_desc_list *cl = 0; 1500 static CGEN_CPU_DESC cd = 0; 1501 static CGEN_BITSET *prev_isa; 1502 static int prev_mach; 1503 static int prev_endian; 1504 int length; 1505 CGEN_BITSET *isa; 1506 int mach; 1507 int endian = (info->endian == BFD_ENDIAN_BIG 1508 ? CGEN_ENDIAN_BIG 1509 : CGEN_ENDIAN_LITTLE); 1510 enum bfd_architecture arch; 1511 1512 /* ??? gdb will set mach but leave the architecture as "unknown" */ 1513#ifndef CGEN_BFD_ARCH 1514#define CGEN_BFD_ARCH bfd_arch_mep 1515#endif 1516 arch = info->arch; 1517 if (arch == bfd_arch_unknown) 1518 arch = CGEN_BFD_ARCH; 1519 1520 /* There's no standard way to compute the machine or isa number 1521 so we leave it to the target. */ 1522#ifdef CGEN_COMPUTE_MACH 1523 mach = CGEN_COMPUTE_MACH (info); 1524#else 1525 mach = info->mach; 1526#endif 1527 1528#ifdef CGEN_COMPUTE_ISA 1529 { 1530 static CGEN_BITSET *permanent_isa; 1531 1532 if (!permanent_isa) 1533 permanent_isa = cgen_bitset_create (MAX_ISAS); 1534 isa = permanent_isa; 1535 cgen_bitset_clear (isa); 1536 cgen_bitset_add (isa, CGEN_COMPUTE_ISA (info)); 1537 } 1538#else 1539 isa = info->insn_sets; 1540#endif 1541 1542 /* If we've switched cpu's, try to find a handle we've used before */ 1543 if (cd 1544 && (cgen_bitset_compare (isa, prev_isa) != 0 1545 || mach != prev_mach 1546 || endian != prev_endian)) 1547 { 1548 cd = 0; 1549 for (cl = cd_list; cl; cl = cl->next) 1550 { 1551 if (cgen_bitset_compare (cl->isa, isa) == 0 && 1552 cl->mach == mach && 1553 cl->endian == endian) 1554 { 1555 cd = cl->cd; 1556 prev_isa = cd->isas; 1557 break; 1558 } 1559 } 1560 } 1561 1562 /* If we haven't initialized yet, initialize the opcode table. */ 1563 if (! cd) 1564 { 1565 const bfd_arch_info_type *arch_type = bfd_lookup_arch (arch, mach); 1566 const char *mach_name; 1567 1568 if (!arch_type) 1569 abort (); 1570 mach_name = arch_type->printable_name; 1571 1572 prev_isa = cgen_bitset_copy (isa); 1573 prev_mach = mach; 1574 prev_endian = endian; 1575 cd = mep_cgen_cpu_open (CGEN_CPU_OPEN_ISAS, prev_isa, 1576 CGEN_CPU_OPEN_BFDMACH, mach_name, 1577 CGEN_CPU_OPEN_ENDIAN, prev_endian, 1578 CGEN_CPU_OPEN_END); 1579 if (!cd) 1580 abort (); 1581 1582 /* Save this away for future reference. */ 1583 cl = xmalloc (sizeof (struct cpu_desc_list)); 1584 cl->cd = cd; 1585 cl->isa = prev_isa; 1586 cl->mach = mach; 1587 cl->endian = endian; 1588 cl->next = cd_list; 1589 cd_list = cl; 1590 1591 mep_cgen_init_dis (cd); 1592 } 1593 1594 /* We try to have as much common code as possible. 1595 But at this point some targets need to take over. */ 1596 /* ??? Some targets may need a hook elsewhere. Try to avoid this, 1597 but if not possible try to move this hook elsewhere rather than 1598 have two hooks. */ 1599 length = CGEN_PRINT_INSN (cd, pc, info); 1600 if (length > 0) 1601 return length; 1602 if (length < 0) 1603 return -1; 1604 1605 (*info->fprintf_func) (info->stream, UNKNOWN_INSN_MSG); 1606 return cd->default_insn_bitsize / 8; 1607} 1608