1/* Instruction building/extraction support for frv. -*- C -*- 2 3THIS FILE IS MACHINE GENERATED WITH CGEN: Cpu tools GENerator. 4- the resultant file is machine generated, cgen-ibld.in isn't 5 6Copyright 1996, 1997, 1998, 1999, 2000, 2001 Free Software Foundation, Inc. 7 8This file is part of the GNU Binutils and GDB, the GNU debugger. 9 10This program is free software; you can redistribute it and/or modify 11it under the terms of the GNU General Public License as published by 12the Free Software Foundation; either version 2, or (at your option) 13any later version. 14 15This program is distributed in the hope that it will be useful, 16but WITHOUT ANY WARRANTY; without even the implied warranty of 17MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 18GNU General Public License for more details. 19 20You should have received a copy of the GNU General Public License 21along with this program; if not, write to the Free Software Foundation, Inc., 2259 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */ 23 24/* ??? Eventually more and more of this stuff can go to cpu-independent files. 25 Keep that in mind. */ 26 27#include "sysdep.h" 28#include <stdio.h> 29#include "ansidecl.h" 30#include "dis-asm.h" 31#include "bfd.h" 32#include "symcat.h" 33#include "frv-desc.h" 34#include "frv-opc.h" 35#include "opintl.h" 36#include "safe-ctype.h" 37 38#undef min 39#define min(a,b) ((a) < (b) ? (a) : (b)) 40#undef max 41#define max(a,b) ((a) > (b) ? (a) : (b)) 42 43/* Used by the ifield rtx function. */ 44#define FLD(f) (fields->f) 45 46static const char * insert_normal 47 (CGEN_CPU_DESC, long, unsigned int, unsigned int, unsigned int, 48 unsigned int, unsigned int, unsigned int, CGEN_INSN_BYTES_PTR); 49static const char * insert_insn_normal 50 (CGEN_CPU_DESC, const CGEN_INSN *, 51 CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma); 52static int extract_normal 53 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, 54 unsigned int, unsigned int, unsigned int, unsigned int, 55 unsigned int, unsigned int, bfd_vma, long *); 56static int extract_insn_normal 57 (CGEN_CPU_DESC, const CGEN_INSN *, CGEN_EXTRACT_INFO *, 58 CGEN_INSN_INT, CGEN_FIELDS *, bfd_vma); 59#if CGEN_INT_INSN_P 60static void put_insn_int_value 61 (CGEN_CPU_DESC, CGEN_INSN_BYTES_PTR, int, int, CGEN_INSN_INT); 62#endif 63#if ! CGEN_INT_INSN_P 64static CGEN_INLINE void insert_1 65 (CGEN_CPU_DESC, unsigned long, int, int, int, unsigned char *); 66static CGEN_INLINE int fill_cache 67 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, bfd_vma); 68static CGEN_INLINE long extract_1 69 (CGEN_CPU_DESC, CGEN_EXTRACT_INFO *, int, int, int, unsigned char *, bfd_vma); 70#endif 71 72/* Operand insertion. */ 73 74#if ! CGEN_INT_INSN_P 75 76/* Subroutine of insert_normal. */ 77 78static CGEN_INLINE void 79insert_1 (CGEN_CPU_DESC cd, 80 unsigned long value, 81 int start, 82 int length, 83 int word_length, 84 unsigned char *bufp) 85{ 86 unsigned long x,mask; 87 int shift; 88 89 x = cgen_get_insn_value (cd, bufp, word_length); 90 91 /* Written this way to avoid undefined behaviour. */ 92 mask = (((1L << (length - 1)) - 1) << 1) | 1; 93 if (CGEN_INSN_LSB0_P) 94 shift = (start + 1) - length; 95 else 96 shift = (word_length - (start + length)); 97 x = (x & ~(mask << shift)) | ((value & mask) << shift); 98 99 cgen_put_insn_value (cd, bufp, word_length, (bfd_vma) x); 100} 101 102#endif /* ! CGEN_INT_INSN_P */ 103 104/* Default insertion routine. 105 106 ATTRS is a mask of the boolean attributes. 107 WORD_OFFSET is the offset in bits from the start of the insn of the value. 108 WORD_LENGTH is the length of the word in bits in which the value resides. 109 START is the starting bit number in the word, architecture origin. 110 LENGTH is the length of VALUE in bits. 111 TOTAL_LENGTH is the total length of the insn in bits. 112 113 The result is an error message or NULL if success. */ 114 115/* ??? This duplicates functionality with bfd's howto table and 116 bfd_install_relocation. */ 117/* ??? This doesn't handle bfd_vma's. Create another function when 118 necessary. */ 119 120static const char * 121insert_normal (CGEN_CPU_DESC cd, 122 long value, 123 unsigned int attrs, 124 unsigned int word_offset, 125 unsigned int start, 126 unsigned int length, 127 unsigned int word_length, 128 unsigned int total_length, 129 CGEN_INSN_BYTES_PTR buffer) 130{ 131 static char errbuf[100]; 132 /* Written this way to avoid undefined behaviour. */ 133 unsigned long mask = (((1L << (length - 1)) - 1) << 1) | 1; 134 135 /* If LENGTH is zero, this operand doesn't contribute to the value. */ 136 if (length == 0) 137 return NULL; 138 139#if 0 140 if (CGEN_INT_INSN_P 141 && word_offset != 0) 142 abort (); 143#endif 144 145 if (word_length > 32) 146 abort (); 147 148 /* For architectures with insns smaller than the base-insn-bitsize, 149 word_length may be too big. */ 150 if (cd->min_insn_bitsize < cd->base_insn_bitsize) 151 { 152 if (word_offset == 0 153 && word_length > total_length) 154 word_length = total_length; 155 } 156 157 /* Ensure VALUE will fit. */ 158 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGN_OPT)) 159 { 160 long minval = - (1L << (length - 1)); 161 unsigned long maxval = mask; 162 163 if ((value > 0 && (unsigned long) value > maxval) 164 || value < minval) 165 { 166 /* xgettext:c-format */ 167 sprintf (errbuf, 168 _("operand out of range (%ld not between %ld and %lu)"), 169 value, minval, maxval); 170 return errbuf; 171 } 172 } 173 else if (! CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED)) 174 { 175 unsigned long maxval = mask; 176 177 if ((unsigned long) value > maxval) 178 { 179 /* xgettext:c-format */ 180 sprintf (errbuf, 181 _("operand out of range (%lu not between 0 and %lu)"), 182 value, maxval); 183 return errbuf; 184 } 185 } 186 else 187 { 188 if (! cgen_signed_overflow_ok_p (cd)) 189 { 190 long minval = - (1L << (length - 1)); 191 long maxval = (1L << (length - 1)) - 1; 192 193 if (value < minval || value > maxval) 194 { 195 sprintf 196 /* xgettext:c-format */ 197 (errbuf, _("operand out of range (%ld not between %ld and %ld)"), 198 value, minval, maxval); 199 return errbuf; 200 } 201 } 202 } 203 204#if CGEN_INT_INSN_P 205 206 { 207 int shift; 208 209 if (CGEN_INSN_LSB0_P) 210 shift = (word_offset + start + 1) - length; 211 else 212 shift = total_length - (word_offset + start + length); 213 *buffer = (*buffer & ~(mask << shift)) | ((value & mask) << shift); 214 } 215 216#else /* ! CGEN_INT_INSN_P */ 217 218 { 219 unsigned char *bufp = (unsigned char *) buffer + word_offset / 8; 220 221 insert_1 (cd, value, start, length, word_length, bufp); 222 } 223 224#endif /* ! CGEN_INT_INSN_P */ 225 226 return NULL; 227} 228 229/* Default insn builder (insert handler). 230 The instruction is recorded in CGEN_INT_INSN_P byte order (meaning 231 that if CGEN_INSN_BYTES_PTR is an int * and thus, the value is 232 recorded in host byte order, otherwise BUFFER is an array of bytes 233 and the value is recorded in target byte order). 234 The result is an error message or NULL if success. */ 235 236static const char * 237insert_insn_normal (CGEN_CPU_DESC cd, 238 const CGEN_INSN * insn, 239 CGEN_FIELDS * fields, 240 CGEN_INSN_BYTES_PTR buffer, 241 bfd_vma pc) 242{ 243 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 244 unsigned long value; 245 const CGEN_SYNTAX_CHAR_TYPE * syn; 246 247 CGEN_INIT_INSERT (cd); 248 value = CGEN_INSN_BASE_VALUE (insn); 249 250 /* If we're recording insns as numbers (rather than a string of bytes), 251 target byte order handling is deferred until later. */ 252 253#if CGEN_INT_INSN_P 254 255 put_insn_int_value (cd, buffer, cd->base_insn_bitsize, 256 CGEN_FIELDS_BITSIZE (fields), value); 257 258#else 259 260 cgen_put_insn_value (cd, buffer, min ((unsigned) cd->base_insn_bitsize, 261 (unsigned) CGEN_FIELDS_BITSIZE (fields)), 262 value); 263 264#endif /* ! CGEN_INT_INSN_P */ 265 266 /* ??? It would be better to scan the format's fields. 267 Still need to be able to insert a value based on the operand though; 268 e.g. storing a branch displacement that got resolved later. 269 Needs more thought first. */ 270 271 for (syn = CGEN_SYNTAX_STRING (syntax); * syn; ++ syn) 272 { 273 const char *errmsg; 274 275 if (CGEN_SYNTAX_CHAR_P (* syn)) 276 continue; 277 278 errmsg = (* cd->insert_operand) (cd, CGEN_SYNTAX_FIELD (*syn), 279 fields, buffer, pc); 280 if (errmsg) 281 return errmsg; 282 } 283 284 return NULL; 285} 286 287#if CGEN_INT_INSN_P 288/* Cover function to store an insn value into an integral insn. Must go here 289 because it needs <prefix>-desc.h for CGEN_INT_INSN_P. */ 290 291static void 292put_insn_int_value (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 293 CGEN_INSN_BYTES_PTR buf, 294 int length, 295 int insn_length, 296 CGEN_INSN_INT value) 297{ 298 /* For architectures with insns smaller than the base-insn-bitsize, 299 length may be too big. */ 300 if (length > insn_length) 301 *buf = value; 302 else 303 { 304 int shift = insn_length - length; 305 /* Written this way to avoid undefined behaviour. */ 306 CGEN_INSN_INT mask = (((1L << (length - 1)) - 1) << 1) | 1; 307 *buf = (*buf & ~(mask << shift)) | ((value & mask) << shift); 308 } 309} 310#endif 311 312/* Operand extraction. */ 313 314#if ! CGEN_INT_INSN_P 315 316/* Subroutine of extract_normal. 317 Ensure sufficient bytes are cached in EX_INFO. 318 OFFSET is the offset in bytes from the start of the insn of the value. 319 BYTES is the length of the needed value. 320 Returns 1 for success, 0 for failure. */ 321 322static CGEN_INLINE int 323fill_cache (CGEN_CPU_DESC cd ATTRIBUTE_UNUSED, 324 CGEN_EXTRACT_INFO *ex_info, 325 int offset, 326 int bytes, 327 bfd_vma pc) 328{ 329 /* It's doubtful that the middle part has already been fetched so 330 we don't optimize that case. kiss. */ 331 unsigned int mask; 332 disassemble_info *info = (disassemble_info *) ex_info->dis_info; 333 334 /* First do a quick check. */ 335 mask = (1 << bytes) - 1; 336 if (((ex_info->valid >> offset) & mask) == mask) 337 return 1; 338 339 /* Search for the first byte we need to read. */ 340 for (mask = 1 << offset; bytes > 0; --bytes, ++offset, mask <<= 1) 341 if (! (mask & ex_info->valid)) 342 break; 343 344 if (bytes) 345 { 346 int status; 347 348 pc += offset; 349 status = (*info->read_memory_func) 350 (pc, ex_info->insn_bytes + offset, bytes, info); 351 352 if (status != 0) 353 { 354 (*info->memory_error_func) (status, pc, info); 355 return 0; 356 } 357 358 ex_info->valid |= ((1 << bytes) - 1) << offset; 359 } 360 361 return 1; 362} 363 364/* Subroutine of extract_normal. */ 365 366static CGEN_INLINE long 367extract_1 (CGEN_CPU_DESC cd, 368 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED, 369 int start, 370 int length, 371 int word_length, 372 unsigned char *bufp, 373 bfd_vma pc ATTRIBUTE_UNUSED) 374{ 375 unsigned long x; 376 int shift; 377#if 0 378 int big_p = CGEN_CPU_INSN_ENDIAN (cd) == CGEN_ENDIAN_BIG; 379#endif 380 x = cgen_get_insn_value (cd, bufp, word_length); 381 382 if (CGEN_INSN_LSB0_P) 383 shift = (start + 1) - length; 384 else 385 shift = (word_length - (start + length)); 386 return x >> shift; 387} 388 389#endif /* ! CGEN_INT_INSN_P */ 390 391/* Default extraction routine. 392 393 INSN_VALUE is the first base_insn_bitsize bits of the insn in host order, 394 or sometimes less for cases like the m32r where the base insn size is 32 395 but some insns are 16 bits. 396 ATTRS is a mask of the boolean attributes. We only need `SIGNED', 397 but for generality we take a bitmask of all of them. 398 WORD_OFFSET is the offset in bits from the start of the insn of the value. 399 WORD_LENGTH is the length of the word in bits in which the value resides. 400 START is the starting bit number in the word, architecture origin. 401 LENGTH is the length of VALUE in bits. 402 TOTAL_LENGTH is the total length of the insn in bits. 403 404 Returns 1 for success, 0 for failure. */ 405 406/* ??? The return code isn't properly used. wip. */ 407 408/* ??? This doesn't handle bfd_vma's. Create another function when 409 necessary. */ 410 411static int 412extract_normal (CGEN_CPU_DESC cd, 413#if ! CGEN_INT_INSN_P 414 CGEN_EXTRACT_INFO *ex_info, 415#else 416 CGEN_EXTRACT_INFO *ex_info ATTRIBUTE_UNUSED, 417#endif 418 CGEN_INSN_INT insn_value, 419 unsigned int attrs, 420 unsigned int word_offset, 421 unsigned int start, 422 unsigned int length, 423 unsigned int word_length, 424 unsigned int total_length, 425#if ! CGEN_INT_INSN_P 426 bfd_vma pc, 427#else 428 bfd_vma pc ATTRIBUTE_UNUSED, 429#endif 430 long *valuep) 431{ 432 long value, mask; 433 434 /* If LENGTH is zero, this operand doesn't contribute to the value 435 so give it a standard value of zero. */ 436 if (length == 0) 437 { 438 *valuep = 0; 439 return 1; 440 } 441 442#if 0 443 if (CGEN_INT_INSN_P 444 && word_offset != 0) 445 abort (); 446#endif 447 448 if (word_length > 32) 449 abort (); 450 451 /* For architectures with insns smaller than the insn-base-bitsize, 452 word_length may be too big. */ 453 if (cd->min_insn_bitsize < cd->base_insn_bitsize) 454 { 455 if (word_offset == 0 456 && word_length > total_length) 457 word_length = total_length; 458 } 459 460 /* Does the value reside in INSN_VALUE, and at the right alignment? */ 461 462 if (CGEN_INT_INSN_P || (word_offset == 0 && word_length == total_length)) 463 { 464 if (CGEN_INSN_LSB0_P) 465 value = insn_value >> ((word_offset + start + 1) - length); 466 else 467 value = insn_value >> (total_length - ( word_offset + start + length)); 468 } 469 470#if ! CGEN_INT_INSN_P 471 472 else 473 { 474 unsigned char *bufp = ex_info->insn_bytes + word_offset / 8; 475 476 if (word_length > 32) 477 abort (); 478 479 if (fill_cache (cd, ex_info, word_offset / 8, word_length / 8, pc) == 0) 480 return 0; 481 482 value = extract_1 (cd, ex_info, start, length, word_length, bufp, pc); 483 } 484 485#endif /* ! CGEN_INT_INSN_P */ 486 487 /* Written this way to avoid undefined behaviour. */ 488 mask = (((1L << (length - 1)) - 1) << 1) | 1; 489 490 value &= mask; 491 /* sign extend? */ 492 if (CGEN_BOOL_ATTR (attrs, CGEN_IFLD_SIGNED) 493 && (value & (1L << (length - 1)))) 494 value |= ~mask; 495 496 *valuep = value; 497 498 return 1; 499} 500 501/* Default insn extractor. 502 503 INSN_VALUE is the first base_insn_bitsize bits, translated to host order. 504 The extracted fields are stored in FIELDS. 505 EX_INFO is used to handle reading variable length insns. 506 Return the length of the insn in bits, or 0 if no match, 507 or -1 if an error occurs fetching data (memory_error_func will have 508 been called). */ 509 510static int 511extract_insn_normal (CGEN_CPU_DESC cd, 512 const CGEN_INSN *insn, 513 CGEN_EXTRACT_INFO *ex_info, 514 CGEN_INSN_INT insn_value, 515 CGEN_FIELDS *fields, 516 bfd_vma pc) 517{ 518 const CGEN_SYNTAX *syntax = CGEN_INSN_SYNTAX (insn); 519 const CGEN_SYNTAX_CHAR_TYPE *syn; 520 521 CGEN_FIELDS_BITSIZE (fields) = CGEN_INSN_BITSIZE (insn); 522 523 CGEN_INIT_EXTRACT (cd); 524 525 for (syn = CGEN_SYNTAX_STRING (syntax); *syn; ++syn) 526 { 527 int length; 528 529 if (CGEN_SYNTAX_CHAR_P (*syn)) 530 continue; 531 532 length = (* cd->extract_operand) (cd, CGEN_SYNTAX_FIELD (*syn), 533 ex_info, insn_value, fields, pc); 534 if (length <= 0) 535 return length; 536 } 537 538 /* We recognized and successfully extracted this insn. */ 539 return CGEN_INSN_BITSIZE (insn); 540} 541 542/* machine generated code added here */ 543 544const char * frv_cgen_insert_operand 545 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, CGEN_INSN_BYTES_PTR, bfd_vma)); 546 547/* Main entry point for operand insertion. 548 549 This function is basically just a big switch statement. Earlier versions 550 used tables to look up the function to use, but 551 - if the table contains both assembler and disassembler functions then 552 the disassembler contains much of the assembler and vice-versa, 553 - there's a lot of inlining possibilities as things grow, 554 - using a switch statement avoids the function call overhead. 555 556 This function could be moved into `parse_insn_normal', but keeping it 557 separate makes clear the interface between `parse_insn_normal' and each of 558 the handlers. It's also needed by GAS to insert operands that couldn't be 559 resolved during parsing. */ 560 561const char * 562frv_cgen_insert_operand (cd, opindex, fields, buffer, pc) 563 CGEN_CPU_DESC cd; 564 int opindex; 565 CGEN_FIELDS * fields; 566 CGEN_INSN_BYTES_PTR buffer; 567 bfd_vma pc ATTRIBUTE_UNUSED; 568{ 569 const char * errmsg = NULL; 570 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields); 571 572 switch (opindex) 573 { 574 case FRV_OPERAND_A0 : 575 errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer); 576 break; 577 case FRV_OPERAND_A1 : 578 errmsg = insert_normal (cd, fields->f_A, 0, 0, 17, 1, 32, total_length, buffer); 579 break; 580 case FRV_OPERAND_ACC40SI : 581 errmsg = insert_normal (cd, fields->f_ACC40Si, 0, 0, 17, 6, 32, total_length, buffer); 582 break; 583 case FRV_OPERAND_ACC40SK : 584 errmsg = insert_normal (cd, fields->f_ACC40Sk, 0, 0, 30, 6, 32, total_length, buffer); 585 break; 586 case FRV_OPERAND_ACC40UI : 587 errmsg = insert_normal (cd, fields->f_ACC40Ui, 0, 0, 17, 6, 32, total_length, buffer); 588 break; 589 case FRV_OPERAND_ACC40UK : 590 errmsg = insert_normal (cd, fields->f_ACC40Uk, 0, 0, 30, 6, 32, total_length, buffer); 591 break; 592 case FRV_OPERAND_ACCGI : 593 errmsg = insert_normal (cd, fields->f_ACCGi, 0, 0, 17, 6, 32, total_length, buffer); 594 break; 595 case FRV_OPERAND_ACCGK : 596 errmsg = insert_normal (cd, fields->f_ACCGk, 0, 0, 30, 6, 32, total_length, buffer); 597 break; 598 case FRV_OPERAND_CCI : 599 errmsg = insert_normal (cd, fields->f_CCi, 0, 0, 11, 3, 32, total_length, buffer); 600 break; 601 case FRV_OPERAND_CPRDOUBLEK : 602 errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer); 603 break; 604 case FRV_OPERAND_CPRI : 605 errmsg = insert_normal (cd, fields->f_CPRi, 0, 0, 17, 6, 32, total_length, buffer); 606 break; 607 case FRV_OPERAND_CPRJ : 608 errmsg = insert_normal (cd, fields->f_CPRj, 0, 0, 5, 6, 32, total_length, buffer); 609 break; 610 case FRV_OPERAND_CPRK : 611 errmsg = insert_normal (cd, fields->f_CPRk, 0, 0, 30, 6, 32, total_length, buffer); 612 break; 613 case FRV_OPERAND_CRI : 614 errmsg = insert_normal (cd, fields->f_CRi, 0, 0, 14, 3, 32, total_length, buffer); 615 break; 616 case FRV_OPERAND_CRJ : 617 errmsg = insert_normal (cd, fields->f_CRj, 0, 0, 2, 3, 32, total_length, buffer); 618 break; 619 case FRV_OPERAND_CRJ_FLOAT : 620 errmsg = insert_normal (cd, fields->f_CRj_float, 0, 0, 26, 2, 32, total_length, buffer); 621 break; 622 case FRV_OPERAND_CRJ_INT : 623 { 624 long value = fields->f_CRj_int; 625 value = ((value) - (4)); 626 errmsg = insert_normal (cd, value, 0, 0, 26, 2, 32, total_length, buffer); 627 } 628 break; 629 case FRV_OPERAND_CRK : 630 errmsg = insert_normal (cd, fields->f_CRk, 0, 0, 27, 3, 32, total_length, buffer); 631 break; 632 case FRV_OPERAND_FCCI_1 : 633 errmsg = insert_normal (cd, fields->f_FCCi_1, 0, 0, 11, 2, 32, total_length, buffer); 634 break; 635 case FRV_OPERAND_FCCI_2 : 636 errmsg = insert_normal (cd, fields->f_FCCi_2, 0, 0, 26, 2, 32, total_length, buffer); 637 break; 638 case FRV_OPERAND_FCCI_3 : 639 errmsg = insert_normal (cd, fields->f_FCCi_3, 0, 0, 1, 2, 32, total_length, buffer); 640 break; 641 case FRV_OPERAND_FCCK : 642 errmsg = insert_normal (cd, fields->f_FCCk, 0, 0, 26, 2, 32, total_length, buffer); 643 break; 644 case FRV_OPERAND_FRDOUBLEI : 645 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer); 646 break; 647 case FRV_OPERAND_FRDOUBLEJ : 648 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer); 649 break; 650 case FRV_OPERAND_FRDOUBLEK : 651 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer); 652 break; 653 case FRV_OPERAND_FRI : 654 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer); 655 break; 656 case FRV_OPERAND_FRINTI : 657 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer); 658 break; 659 case FRV_OPERAND_FRINTIEVEN : 660 errmsg = insert_normal (cd, fields->f_FRi, 0, 0, 17, 6, 32, total_length, buffer); 661 break; 662 case FRV_OPERAND_FRINTJ : 663 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer); 664 break; 665 case FRV_OPERAND_FRINTJEVEN : 666 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer); 667 break; 668 case FRV_OPERAND_FRINTK : 669 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer); 670 break; 671 case FRV_OPERAND_FRINTKEVEN : 672 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer); 673 break; 674 case FRV_OPERAND_FRJ : 675 errmsg = insert_normal (cd, fields->f_FRj, 0, 0, 5, 6, 32, total_length, buffer); 676 break; 677 case FRV_OPERAND_FRK : 678 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer); 679 break; 680 case FRV_OPERAND_FRKHI : 681 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer); 682 break; 683 case FRV_OPERAND_FRKLO : 684 errmsg = insert_normal (cd, fields->f_FRk, 0, 0, 30, 6, 32, total_length, buffer); 685 break; 686 case FRV_OPERAND_GRDOUBLEK : 687 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer); 688 break; 689 case FRV_OPERAND_GRI : 690 errmsg = insert_normal (cd, fields->f_GRi, 0, 0, 17, 6, 32, total_length, buffer); 691 break; 692 case FRV_OPERAND_GRJ : 693 errmsg = insert_normal (cd, fields->f_GRj, 0, 0, 5, 6, 32, total_length, buffer); 694 break; 695 case FRV_OPERAND_GRK : 696 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer); 697 break; 698 case FRV_OPERAND_GRKHI : 699 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer); 700 break; 701 case FRV_OPERAND_GRKLO : 702 errmsg = insert_normal (cd, fields->f_GRk, 0, 0, 30, 6, 32, total_length, buffer); 703 break; 704 case FRV_OPERAND_ICCI_1 : 705 errmsg = insert_normal (cd, fields->f_ICCi_1, 0, 0, 11, 2, 32, total_length, buffer); 706 break; 707 case FRV_OPERAND_ICCI_2 : 708 errmsg = insert_normal (cd, fields->f_ICCi_2, 0, 0, 26, 2, 32, total_length, buffer); 709 break; 710 case FRV_OPERAND_ICCI_3 : 711 errmsg = insert_normal (cd, fields->f_ICCi_3, 0, 0, 1, 2, 32, total_length, buffer); 712 break; 713 case FRV_OPERAND_LI : 714 errmsg = insert_normal (cd, fields->f_LI, 0, 0, 25, 1, 32, total_length, buffer); 715 break; 716 case FRV_OPERAND_LRAD : 717 errmsg = insert_normal (cd, fields->f_LRAD, 0, 0, 4, 1, 32, total_length, buffer); 718 break; 719 case FRV_OPERAND_LRAE : 720 errmsg = insert_normal (cd, fields->f_LRAE, 0, 0, 5, 1, 32, total_length, buffer); 721 break; 722 case FRV_OPERAND_LRAS : 723 errmsg = insert_normal (cd, fields->f_LRAS, 0, 0, 3, 1, 32, total_length, buffer); 724 break; 725 case FRV_OPERAND_TLBPRL : 726 errmsg = insert_normal (cd, fields->f_TLBPRL, 0, 0, 25, 1, 32, total_length, buffer); 727 break; 728 case FRV_OPERAND_TLBPROPX : 729 errmsg = insert_normal (cd, fields->f_TLBPRopx, 0, 0, 28, 3, 32, total_length, buffer); 730 break; 731 case FRV_OPERAND_AE : 732 errmsg = insert_normal (cd, fields->f_ae, 0, 0, 25, 1, 32, total_length, buffer); 733 break; 734 case FRV_OPERAND_CCOND : 735 errmsg = insert_normal (cd, fields->f_ccond, 0, 0, 12, 1, 32, total_length, buffer); 736 break; 737 case FRV_OPERAND_COND : 738 errmsg = insert_normal (cd, fields->f_cond, 0, 0, 8, 1, 32, total_length, buffer); 739 break; 740 case FRV_OPERAND_D12 : 741 errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer); 742 break; 743 case FRV_OPERAND_DEBUG : 744 errmsg = insert_normal (cd, fields->f_debug, 0, 0, 25, 1, 32, total_length, buffer); 745 break; 746 case FRV_OPERAND_EIR : 747 errmsg = insert_normal (cd, fields->f_eir, 0, 0, 17, 6, 32, total_length, buffer); 748 break; 749 case FRV_OPERAND_HINT : 750 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer); 751 break; 752 case FRV_OPERAND_HINT_NOT_TAKEN : 753 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer); 754 break; 755 case FRV_OPERAND_HINT_TAKEN : 756 errmsg = insert_normal (cd, fields->f_hint, 0, 0, 17, 2, 32, total_length, buffer); 757 break; 758 case FRV_OPERAND_LABEL16 : 759 { 760 long value = fields->f_label16; 761 value = ((int) (((value) - (pc))) >> (2)); 762 errmsg = insert_normal (cd, value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, buffer); 763 } 764 break; 765 case FRV_OPERAND_LABEL24 : 766 { 767{ 768 FLD (f_labelH6) = ((int) (((FLD (f_label24)) - (pc))) >> (20)); 769 FLD (f_labelL18) = ((((unsigned int) (((FLD (f_label24)) - (pc))) >> (2))) & (262143)); 770} 771 errmsg = insert_normal (cd, fields->f_labelH6, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, buffer); 772 if (errmsg) 773 break; 774 errmsg = insert_normal (cd, fields->f_labelL18, 0, 0, 17, 18, 32, total_length, buffer); 775 if (errmsg) 776 break; 777 } 778 break; 779 case FRV_OPERAND_LOCK : 780 errmsg = insert_normal (cd, fields->f_lock, 0, 0, 25, 1, 32, total_length, buffer); 781 break; 782 case FRV_OPERAND_PACK : 783 errmsg = insert_normal (cd, fields->f_pack, 0, 0, 31, 1, 32, total_length, buffer); 784 break; 785 case FRV_OPERAND_S10 : 786 errmsg = insert_normal (cd, fields->f_s10, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, buffer); 787 break; 788 case FRV_OPERAND_S12 : 789 errmsg = insert_normal (cd, fields->f_d12, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, buffer); 790 break; 791 case FRV_OPERAND_S16 : 792 errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer); 793 break; 794 case FRV_OPERAND_S5 : 795 errmsg = insert_normal (cd, fields->f_s5, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, buffer); 796 break; 797 case FRV_OPERAND_S6 : 798 errmsg = insert_normal (cd, fields->f_s6, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, buffer); 799 break; 800 case FRV_OPERAND_S6_1 : 801 errmsg = insert_normal (cd, fields->f_s6_1, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, buffer); 802 break; 803 case FRV_OPERAND_SLO16 : 804 errmsg = insert_normal (cd, fields->f_s16, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, buffer); 805 break; 806 case FRV_OPERAND_SPR : 807 { 808{ 809 FLD (f_spr_h) = ((unsigned int) (FLD (f_spr)) >> (6)); 810 FLD (f_spr_l) = ((FLD (f_spr)) & (63)); 811} 812 errmsg = insert_normal (cd, fields->f_spr_h, 0, 0, 30, 6, 32, total_length, buffer); 813 if (errmsg) 814 break; 815 errmsg = insert_normal (cd, fields->f_spr_l, 0, 0, 17, 6, 32, total_length, buffer); 816 if (errmsg) 817 break; 818 } 819 break; 820 case FRV_OPERAND_U12 : 821 { 822{ 823 FLD (f_u12_h) = ((int) (FLD (f_u12)) >> (6)); 824 FLD (f_u12_l) = ((FLD (f_u12)) & (63)); 825} 826 errmsg = insert_normal (cd, fields->f_u12_h, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, buffer); 827 if (errmsg) 828 break; 829 errmsg = insert_normal (cd, fields->f_u12_l, 0, 0, 5, 6, 32, total_length, buffer); 830 if (errmsg) 831 break; 832 } 833 break; 834 case FRV_OPERAND_U16 : 835 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer); 836 break; 837 case FRV_OPERAND_U6 : 838 errmsg = insert_normal (cd, fields->f_u6, 0, 0, 5, 6, 32, total_length, buffer); 839 break; 840 case FRV_OPERAND_UHI16 : 841 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer); 842 break; 843 case FRV_OPERAND_ULO16 : 844 errmsg = insert_normal (cd, fields->f_u16, 0, 0, 15, 16, 32, total_length, buffer); 845 break; 846 847 default : 848 /* xgettext:c-format */ 849 fprintf (stderr, _("Unrecognized field %d while building insn.\n"), 850 opindex); 851 abort (); 852 } 853 854 return errmsg; 855} 856 857int frv_cgen_extract_operand 858 PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, 859 CGEN_FIELDS *, bfd_vma)); 860 861/* Main entry point for operand extraction. 862 The result is <= 0 for error, >0 for success. 863 ??? Actual values aren't well defined right now. 864 865 This function is basically just a big switch statement. Earlier versions 866 used tables to look up the function to use, but 867 - if the table contains both assembler and disassembler functions then 868 the disassembler contains much of the assembler and vice-versa, 869 - there's a lot of inlining possibilities as things grow, 870 - using a switch statement avoids the function call overhead. 871 872 This function could be moved into `print_insn_normal', but keeping it 873 separate makes clear the interface between `print_insn_normal' and each of 874 the handlers. */ 875 876int 877frv_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc) 878 CGEN_CPU_DESC cd; 879 int opindex; 880 CGEN_EXTRACT_INFO *ex_info; 881 CGEN_INSN_INT insn_value; 882 CGEN_FIELDS * fields; 883 bfd_vma pc; 884{ 885 /* Assume success (for those operands that are nops). */ 886 int length = 1; 887 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields); 888 889 switch (opindex) 890 { 891 case FRV_OPERAND_A0 : 892 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A); 893 break; 894 case FRV_OPERAND_A1 : 895 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 1, 32, total_length, pc, & fields->f_A); 896 break; 897 case FRV_OPERAND_ACC40SI : 898 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Si); 899 break; 900 case FRV_OPERAND_ACC40SK : 901 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Sk); 902 break; 903 case FRV_OPERAND_ACC40UI : 904 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACC40Ui); 905 break; 906 case FRV_OPERAND_ACC40UK : 907 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACC40Uk); 908 break; 909 case FRV_OPERAND_ACCGI : 910 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_ACCGi); 911 break; 912 case FRV_OPERAND_ACCGK : 913 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_ACCGk); 914 break; 915 case FRV_OPERAND_CCI : 916 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 32, total_length, pc, & fields->f_CCi); 917 break; 918 case FRV_OPERAND_CPRDOUBLEK : 919 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk); 920 break; 921 case FRV_OPERAND_CPRI : 922 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_CPRi); 923 break; 924 case FRV_OPERAND_CPRJ : 925 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_CPRj); 926 break; 927 case FRV_OPERAND_CPRK : 928 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_CPRk); 929 break; 930 case FRV_OPERAND_CRI : 931 length = extract_normal (cd, ex_info, insn_value, 0, 0, 14, 3, 32, total_length, pc, & fields->f_CRi); 932 break; 933 case FRV_OPERAND_CRJ : 934 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 32, total_length, pc, & fields->f_CRj); 935 break; 936 case FRV_OPERAND_CRJ_FLOAT : 937 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_CRj_float); 938 break; 939 case FRV_OPERAND_CRJ_INT : 940 { 941 long value; 942 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & value); 943 value = ((value) + (4)); 944 fields->f_CRj_int = value; 945 } 946 break; 947 case FRV_OPERAND_CRK : 948 length = extract_normal (cd, ex_info, insn_value, 0, 0, 27, 3, 32, total_length, pc, & fields->f_CRk); 949 break; 950 case FRV_OPERAND_FCCI_1 : 951 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_FCCi_1); 952 break; 953 case FRV_OPERAND_FCCI_2 : 954 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCi_2); 955 break; 956 case FRV_OPERAND_FCCI_3 : 957 length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_FCCi_3); 958 break; 959 case FRV_OPERAND_FCCK : 960 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_FCCk); 961 break; 962 case FRV_OPERAND_FRDOUBLEI : 963 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi); 964 break; 965 case FRV_OPERAND_FRDOUBLEJ : 966 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj); 967 break; 968 case FRV_OPERAND_FRDOUBLEK : 969 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk); 970 break; 971 case FRV_OPERAND_FRI : 972 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi); 973 break; 974 case FRV_OPERAND_FRINTI : 975 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi); 976 break; 977 case FRV_OPERAND_FRINTIEVEN : 978 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_FRi); 979 break; 980 case FRV_OPERAND_FRINTJ : 981 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj); 982 break; 983 case FRV_OPERAND_FRINTJEVEN : 984 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj); 985 break; 986 case FRV_OPERAND_FRINTK : 987 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk); 988 break; 989 case FRV_OPERAND_FRINTKEVEN : 990 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk); 991 break; 992 case FRV_OPERAND_FRJ : 993 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_FRj); 994 break; 995 case FRV_OPERAND_FRK : 996 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk); 997 break; 998 case FRV_OPERAND_FRKHI : 999 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk); 1000 break; 1001 case FRV_OPERAND_FRKLO : 1002 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_FRk); 1003 break; 1004 case FRV_OPERAND_GRDOUBLEK : 1005 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk); 1006 break; 1007 case FRV_OPERAND_GRI : 1008 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_GRi); 1009 break; 1010 case FRV_OPERAND_GRJ : 1011 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_GRj); 1012 break; 1013 case FRV_OPERAND_GRK : 1014 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk); 1015 break; 1016 case FRV_OPERAND_GRKHI : 1017 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk); 1018 break; 1019 case FRV_OPERAND_GRKLO : 1020 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_GRk); 1021 break; 1022 case FRV_OPERAND_ICCI_1 : 1023 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 2, 32, total_length, pc, & fields->f_ICCi_1); 1024 break; 1025 case FRV_OPERAND_ICCI_2 : 1026 length = extract_normal (cd, ex_info, insn_value, 0, 0, 26, 2, 32, total_length, pc, & fields->f_ICCi_2); 1027 break; 1028 case FRV_OPERAND_ICCI_3 : 1029 length = extract_normal (cd, ex_info, insn_value, 0, 0, 1, 2, 32, total_length, pc, & fields->f_ICCi_3); 1030 break; 1031 case FRV_OPERAND_LI : 1032 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_LI); 1033 break; 1034 case FRV_OPERAND_LRAD : 1035 length = extract_normal (cd, ex_info, insn_value, 0, 0, 4, 1, 32, total_length, pc, & fields->f_LRAD); 1036 break; 1037 case FRV_OPERAND_LRAE : 1038 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 1, 32, total_length, pc, & fields->f_LRAE); 1039 break; 1040 case FRV_OPERAND_LRAS : 1041 length = extract_normal (cd, ex_info, insn_value, 0, 0, 3, 1, 32, total_length, pc, & fields->f_LRAS); 1042 break; 1043 case FRV_OPERAND_TLBPRL : 1044 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_TLBPRL); 1045 break; 1046 case FRV_OPERAND_TLBPROPX : 1047 length = extract_normal (cd, ex_info, insn_value, 0, 0, 28, 3, 32, total_length, pc, & fields->f_TLBPRopx); 1048 break; 1049 case FRV_OPERAND_AE : 1050 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_ae); 1051 break; 1052 case FRV_OPERAND_CCOND : 1053 length = extract_normal (cd, ex_info, insn_value, 0, 0, 12, 1, 32, total_length, pc, & fields->f_ccond); 1054 break; 1055 case FRV_OPERAND_COND : 1056 length = extract_normal (cd, ex_info, insn_value, 0, 0, 8, 1, 32, total_length, pc, & fields->f_cond); 1057 break; 1058 case FRV_OPERAND_D12 : 1059 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12); 1060 break; 1061 case FRV_OPERAND_DEBUG : 1062 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_debug); 1063 break; 1064 case FRV_OPERAND_EIR : 1065 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_eir); 1066 break; 1067 case FRV_OPERAND_HINT : 1068 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint); 1069 break; 1070 case FRV_OPERAND_HINT_NOT_TAKEN : 1071 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint); 1072 break; 1073 case FRV_OPERAND_HINT_TAKEN : 1074 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 2, 32, total_length, pc, & fields->f_hint); 1075 break; 1076 case FRV_OPERAND_LABEL16 : 1077 { 1078 long value; 1079 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED)|(1<<CGEN_IFLD_PCREL_ADDR), 0, 15, 16, 32, total_length, pc, & value); 1080 value = ((((value) << (2))) + (pc)); 1081 fields->f_label16 = value; 1082 } 1083 break; 1084 case FRV_OPERAND_LABEL24 : 1085 { 1086 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 30, 6, 32, total_length, pc, & fields->f_labelH6); 1087 if (length <= 0) break; 1088 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 18, 32, total_length, pc, & fields->f_labelL18); 1089 if (length <= 0) break; 1090{ 1091 FLD (f_label24) = ((((((((FLD (f_labelH6)) << (18))) | (FLD (f_labelL18)))) << (2))) + (pc)); 1092} 1093 } 1094 break; 1095 case FRV_OPERAND_LOCK : 1096 length = extract_normal (cd, ex_info, insn_value, 0, 0, 25, 1, 32, total_length, pc, & fields->f_lock); 1097 break; 1098 case FRV_OPERAND_PACK : 1099 length = extract_normal (cd, ex_info, insn_value, 0, 0, 31, 1, 32, total_length, pc, & fields->f_pack); 1100 break; 1101 case FRV_OPERAND_S10 : 1102 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 9, 10, 32, total_length, pc, & fields->f_s10); 1103 break; 1104 case FRV_OPERAND_S12 : 1105 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 12, 32, total_length, pc, & fields->f_d12); 1106 break; 1107 case FRV_OPERAND_S16 : 1108 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16); 1109 break; 1110 case FRV_OPERAND_S5 : 1111 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 4, 5, 32, total_length, pc, & fields->f_s5); 1112 break; 1113 case FRV_OPERAND_S6 : 1114 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 5, 6, 32, total_length, pc, & fields->f_s6); 1115 break; 1116 case FRV_OPERAND_S6_1 : 1117 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 11, 6, 32, total_length, pc, & fields->f_s6_1); 1118 break; 1119 case FRV_OPERAND_SLO16 : 1120 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 15, 16, 32, total_length, pc, & fields->f_s16); 1121 break; 1122 case FRV_OPERAND_SPR : 1123 { 1124 length = extract_normal (cd, ex_info, insn_value, 0, 0, 30, 6, 32, total_length, pc, & fields->f_spr_h); 1125 if (length <= 0) break; 1126 length = extract_normal (cd, ex_info, insn_value, 0, 0, 17, 6, 32, total_length, pc, & fields->f_spr_l); 1127 if (length <= 0) break; 1128{ 1129 FLD (f_spr) = ((((FLD (f_spr_h)) << (6))) | (FLD (f_spr_l))); 1130} 1131 } 1132 break; 1133 case FRV_OPERAND_U12 : 1134 { 1135 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_SIGNED), 0, 17, 6, 32, total_length, pc, & fields->f_u12_h); 1136 if (length <= 0) break; 1137 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u12_l); 1138 if (length <= 0) break; 1139{ 1140 FLD (f_u12) = ((((FLD (f_u12_h)) << (6))) | (FLD (f_u12_l))); 1141} 1142 } 1143 break; 1144 case FRV_OPERAND_U16 : 1145 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16); 1146 break; 1147 case FRV_OPERAND_U6 : 1148 length = extract_normal (cd, ex_info, insn_value, 0, 0, 5, 6, 32, total_length, pc, & fields->f_u6); 1149 break; 1150 case FRV_OPERAND_UHI16 : 1151 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16); 1152 break; 1153 case FRV_OPERAND_ULO16 : 1154 length = extract_normal (cd, ex_info, insn_value, 0, 0, 15, 16, 32, total_length, pc, & fields->f_u16); 1155 break; 1156 1157 default : 1158 /* xgettext:c-format */ 1159 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"), 1160 opindex); 1161 abort (); 1162 } 1163 1164 return length; 1165} 1166 1167cgen_insert_fn * const frv_cgen_insert_handlers[] = 1168{ 1169 insert_insn_normal, 1170}; 1171 1172cgen_extract_fn * const frv_cgen_extract_handlers[] = 1173{ 1174 extract_insn_normal, 1175}; 1176 1177int frv_cgen_get_int_operand 1178 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *)); 1179bfd_vma frv_cgen_get_vma_operand 1180 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *)); 1181 1182/* Getting values from cgen_fields is handled by a collection of functions. 1183 They are distinguished by the type of the VALUE argument they return. 1184 TODO: floating point, inlining support, remove cases where result type 1185 not appropriate. */ 1186 1187int 1188frv_cgen_get_int_operand (cd, opindex, fields) 1189 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 1190 int opindex; 1191 const CGEN_FIELDS * fields; 1192{ 1193 int value; 1194 1195 switch (opindex) 1196 { 1197 case FRV_OPERAND_A0 : 1198 value = fields->f_A; 1199 break; 1200 case FRV_OPERAND_A1 : 1201 value = fields->f_A; 1202 break; 1203 case FRV_OPERAND_ACC40SI : 1204 value = fields->f_ACC40Si; 1205 break; 1206 case FRV_OPERAND_ACC40SK : 1207 value = fields->f_ACC40Sk; 1208 break; 1209 case FRV_OPERAND_ACC40UI : 1210 value = fields->f_ACC40Ui; 1211 break; 1212 case FRV_OPERAND_ACC40UK : 1213 value = fields->f_ACC40Uk; 1214 break; 1215 case FRV_OPERAND_ACCGI : 1216 value = fields->f_ACCGi; 1217 break; 1218 case FRV_OPERAND_ACCGK : 1219 value = fields->f_ACCGk; 1220 break; 1221 case FRV_OPERAND_CCI : 1222 value = fields->f_CCi; 1223 break; 1224 case FRV_OPERAND_CPRDOUBLEK : 1225 value = fields->f_CPRk; 1226 break; 1227 case FRV_OPERAND_CPRI : 1228 value = fields->f_CPRi; 1229 break; 1230 case FRV_OPERAND_CPRJ : 1231 value = fields->f_CPRj; 1232 break; 1233 case FRV_OPERAND_CPRK : 1234 value = fields->f_CPRk; 1235 break; 1236 case FRV_OPERAND_CRI : 1237 value = fields->f_CRi; 1238 break; 1239 case FRV_OPERAND_CRJ : 1240 value = fields->f_CRj; 1241 break; 1242 case FRV_OPERAND_CRJ_FLOAT : 1243 value = fields->f_CRj_float; 1244 break; 1245 case FRV_OPERAND_CRJ_INT : 1246 value = fields->f_CRj_int; 1247 break; 1248 case FRV_OPERAND_CRK : 1249 value = fields->f_CRk; 1250 break; 1251 case FRV_OPERAND_FCCI_1 : 1252 value = fields->f_FCCi_1; 1253 break; 1254 case FRV_OPERAND_FCCI_2 : 1255 value = fields->f_FCCi_2; 1256 break; 1257 case FRV_OPERAND_FCCI_3 : 1258 value = fields->f_FCCi_3; 1259 break; 1260 case FRV_OPERAND_FCCK : 1261 value = fields->f_FCCk; 1262 break; 1263 case FRV_OPERAND_FRDOUBLEI : 1264 value = fields->f_FRi; 1265 break; 1266 case FRV_OPERAND_FRDOUBLEJ : 1267 value = fields->f_FRj; 1268 break; 1269 case FRV_OPERAND_FRDOUBLEK : 1270 value = fields->f_FRk; 1271 break; 1272 case FRV_OPERAND_FRI : 1273 value = fields->f_FRi; 1274 break; 1275 case FRV_OPERAND_FRINTI : 1276 value = fields->f_FRi; 1277 break; 1278 case FRV_OPERAND_FRINTIEVEN : 1279 value = fields->f_FRi; 1280 break; 1281 case FRV_OPERAND_FRINTJ : 1282 value = fields->f_FRj; 1283 break; 1284 case FRV_OPERAND_FRINTJEVEN : 1285 value = fields->f_FRj; 1286 break; 1287 case FRV_OPERAND_FRINTK : 1288 value = fields->f_FRk; 1289 break; 1290 case FRV_OPERAND_FRINTKEVEN : 1291 value = fields->f_FRk; 1292 break; 1293 case FRV_OPERAND_FRJ : 1294 value = fields->f_FRj; 1295 break; 1296 case FRV_OPERAND_FRK : 1297 value = fields->f_FRk; 1298 break; 1299 case FRV_OPERAND_FRKHI : 1300 value = fields->f_FRk; 1301 break; 1302 case FRV_OPERAND_FRKLO : 1303 value = fields->f_FRk; 1304 break; 1305 case FRV_OPERAND_GRDOUBLEK : 1306 value = fields->f_GRk; 1307 break; 1308 case FRV_OPERAND_GRI : 1309 value = fields->f_GRi; 1310 break; 1311 case FRV_OPERAND_GRJ : 1312 value = fields->f_GRj; 1313 break; 1314 case FRV_OPERAND_GRK : 1315 value = fields->f_GRk; 1316 break; 1317 case FRV_OPERAND_GRKHI : 1318 value = fields->f_GRk; 1319 break; 1320 case FRV_OPERAND_GRKLO : 1321 value = fields->f_GRk; 1322 break; 1323 case FRV_OPERAND_ICCI_1 : 1324 value = fields->f_ICCi_1; 1325 break; 1326 case FRV_OPERAND_ICCI_2 : 1327 value = fields->f_ICCi_2; 1328 break; 1329 case FRV_OPERAND_ICCI_3 : 1330 value = fields->f_ICCi_3; 1331 break; 1332 case FRV_OPERAND_LI : 1333 value = fields->f_LI; 1334 break; 1335 case FRV_OPERAND_LRAD : 1336 value = fields->f_LRAD; 1337 break; 1338 case FRV_OPERAND_LRAE : 1339 value = fields->f_LRAE; 1340 break; 1341 case FRV_OPERAND_LRAS : 1342 value = fields->f_LRAS; 1343 break; 1344 case FRV_OPERAND_TLBPRL : 1345 value = fields->f_TLBPRL; 1346 break; 1347 case FRV_OPERAND_TLBPROPX : 1348 value = fields->f_TLBPRopx; 1349 break; 1350 case FRV_OPERAND_AE : 1351 value = fields->f_ae; 1352 break; 1353 case FRV_OPERAND_CCOND : 1354 value = fields->f_ccond; 1355 break; 1356 case FRV_OPERAND_COND : 1357 value = fields->f_cond; 1358 break; 1359 case FRV_OPERAND_D12 : 1360 value = fields->f_d12; 1361 break; 1362 case FRV_OPERAND_DEBUG : 1363 value = fields->f_debug; 1364 break; 1365 case FRV_OPERAND_EIR : 1366 value = fields->f_eir; 1367 break; 1368 case FRV_OPERAND_HINT : 1369 value = fields->f_hint; 1370 break; 1371 case FRV_OPERAND_HINT_NOT_TAKEN : 1372 value = fields->f_hint; 1373 break; 1374 case FRV_OPERAND_HINT_TAKEN : 1375 value = fields->f_hint; 1376 break; 1377 case FRV_OPERAND_LABEL16 : 1378 value = fields->f_label16; 1379 break; 1380 case FRV_OPERAND_LABEL24 : 1381 value = fields->f_label24; 1382 break; 1383 case FRV_OPERAND_LOCK : 1384 value = fields->f_lock; 1385 break; 1386 case FRV_OPERAND_PACK : 1387 value = fields->f_pack; 1388 break; 1389 case FRV_OPERAND_S10 : 1390 value = fields->f_s10; 1391 break; 1392 case FRV_OPERAND_S12 : 1393 value = fields->f_d12; 1394 break; 1395 case FRV_OPERAND_S16 : 1396 value = fields->f_s16; 1397 break; 1398 case FRV_OPERAND_S5 : 1399 value = fields->f_s5; 1400 break; 1401 case FRV_OPERAND_S6 : 1402 value = fields->f_s6; 1403 break; 1404 case FRV_OPERAND_S6_1 : 1405 value = fields->f_s6_1; 1406 break; 1407 case FRV_OPERAND_SLO16 : 1408 value = fields->f_s16; 1409 break; 1410 case FRV_OPERAND_SPR : 1411 value = fields->f_spr; 1412 break; 1413 case FRV_OPERAND_U12 : 1414 value = fields->f_u12; 1415 break; 1416 case FRV_OPERAND_U16 : 1417 value = fields->f_u16; 1418 break; 1419 case FRV_OPERAND_U6 : 1420 value = fields->f_u6; 1421 break; 1422 case FRV_OPERAND_UHI16 : 1423 value = fields->f_u16; 1424 break; 1425 case FRV_OPERAND_ULO16 : 1426 value = fields->f_u16; 1427 break; 1428 1429 default : 1430 /* xgettext:c-format */ 1431 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"), 1432 opindex); 1433 abort (); 1434 } 1435 1436 return value; 1437} 1438 1439bfd_vma 1440frv_cgen_get_vma_operand (cd, opindex, fields) 1441 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 1442 int opindex; 1443 const CGEN_FIELDS * fields; 1444{ 1445 bfd_vma value; 1446 1447 switch (opindex) 1448 { 1449 case FRV_OPERAND_A0 : 1450 value = fields->f_A; 1451 break; 1452 case FRV_OPERAND_A1 : 1453 value = fields->f_A; 1454 break; 1455 case FRV_OPERAND_ACC40SI : 1456 value = fields->f_ACC40Si; 1457 break; 1458 case FRV_OPERAND_ACC40SK : 1459 value = fields->f_ACC40Sk; 1460 break; 1461 case FRV_OPERAND_ACC40UI : 1462 value = fields->f_ACC40Ui; 1463 break; 1464 case FRV_OPERAND_ACC40UK : 1465 value = fields->f_ACC40Uk; 1466 break; 1467 case FRV_OPERAND_ACCGI : 1468 value = fields->f_ACCGi; 1469 break; 1470 case FRV_OPERAND_ACCGK : 1471 value = fields->f_ACCGk; 1472 break; 1473 case FRV_OPERAND_CCI : 1474 value = fields->f_CCi; 1475 break; 1476 case FRV_OPERAND_CPRDOUBLEK : 1477 value = fields->f_CPRk; 1478 break; 1479 case FRV_OPERAND_CPRI : 1480 value = fields->f_CPRi; 1481 break; 1482 case FRV_OPERAND_CPRJ : 1483 value = fields->f_CPRj; 1484 break; 1485 case FRV_OPERAND_CPRK : 1486 value = fields->f_CPRk; 1487 break; 1488 case FRV_OPERAND_CRI : 1489 value = fields->f_CRi; 1490 break; 1491 case FRV_OPERAND_CRJ : 1492 value = fields->f_CRj; 1493 break; 1494 case FRV_OPERAND_CRJ_FLOAT : 1495 value = fields->f_CRj_float; 1496 break; 1497 case FRV_OPERAND_CRJ_INT : 1498 value = fields->f_CRj_int; 1499 break; 1500 case FRV_OPERAND_CRK : 1501 value = fields->f_CRk; 1502 break; 1503 case FRV_OPERAND_FCCI_1 : 1504 value = fields->f_FCCi_1; 1505 break; 1506 case FRV_OPERAND_FCCI_2 : 1507 value = fields->f_FCCi_2; 1508 break; 1509 case FRV_OPERAND_FCCI_3 : 1510 value = fields->f_FCCi_3; 1511 break; 1512 case FRV_OPERAND_FCCK : 1513 value = fields->f_FCCk; 1514 break; 1515 case FRV_OPERAND_FRDOUBLEI : 1516 value = fields->f_FRi; 1517 break; 1518 case FRV_OPERAND_FRDOUBLEJ : 1519 value = fields->f_FRj; 1520 break; 1521 case FRV_OPERAND_FRDOUBLEK : 1522 value = fields->f_FRk; 1523 break; 1524 case FRV_OPERAND_FRI : 1525 value = fields->f_FRi; 1526 break; 1527 case FRV_OPERAND_FRINTI : 1528 value = fields->f_FRi; 1529 break; 1530 case FRV_OPERAND_FRINTIEVEN : 1531 value = fields->f_FRi; 1532 break; 1533 case FRV_OPERAND_FRINTJ : 1534 value = fields->f_FRj; 1535 break; 1536 case FRV_OPERAND_FRINTJEVEN : 1537 value = fields->f_FRj; 1538 break; 1539 case FRV_OPERAND_FRINTK : 1540 value = fields->f_FRk; 1541 break; 1542 case FRV_OPERAND_FRINTKEVEN : 1543 value = fields->f_FRk; 1544 break; 1545 case FRV_OPERAND_FRJ : 1546 value = fields->f_FRj; 1547 break; 1548 case FRV_OPERAND_FRK : 1549 value = fields->f_FRk; 1550 break; 1551 case FRV_OPERAND_FRKHI : 1552 value = fields->f_FRk; 1553 break; 1554 case FRV_OPERAND_FRKLO : 1555 value = fields->f_FRk; 1556 break; 1557 case FRV_OPERAND_GRDOUBLEK : 1558 value = fields->f_GRk; 1559 break; 1560 case FRV_OPERAND_GRI : 1561 value = fields->f_GRi; 1562 break; 1563 case FRV_OPERAND_GRJ : 1564 value = fields->f_GRj; 1565 break; 1566 case FRV_OPERAND_GRK : 1567 value = fields->f_GRk; 1568 break; 1569 case FRV_OPERAND_GRKHI : 1570 value = fields->f_GRk; 1571 break; 1572 case FRV_OPERAND_GRKLO : 1573 value = fields->f_GRk; 1574 break; 1575 case FRV_OPERAND_ICCI_1 : 1576 value = fields->f_ICCi_1; 1577 break; 1578 case FRV_OPERAND_ICCI_2 : 1579 value = fields->f_ICCi_2; 1580 break; 1581 case FRV_OPERAND_ICCI_3 : 1582 value = fields->f_ICCi_3; 1583 break; 1584 case FRV_OPERAND_LI : 1585 value = fields->f_LI; 1586 break; 1587 case FRV_OPERAND_LRAD : 1588 value = fields->f_LRAD; 1589 break; 1590 case FRV_OPERAND_LRAE : 1591 value = fields->f_LRAE; 1592 break; 1593 case FRV_OPERAND_LRAS : 1594 value = fields->f_LRAS; 1595 break; 1596 case FRV_OPERAND_TLBPRL : 1597 value = fields->f_TLBPRL; 1598 break; 1599 case FRV_OPERAND_TLBPROPX : 1600 value = fields->f_TLBPRopx; 1601 break; 1602 case FRV_OPERAND_AE : 1603 value = fields->f_ae; 1604 break; 1605 case FRV_OPERAND_CCOND : 1606 value = fields->f_ccond; 1607 break; 1608 case FRV_OPERAND_COND : 1609 value = fields->f_cond; 1610 break; 1611 case FRV_OPERAND_D12 : 1612 value = fields->f_d12; 1613 break; 1614 case FRV_OPERAND_DEBUG : 1615 value = fields->f_debug; 1616 break; 1617 case FRV_OPERAND_EIR : 1618 value = fields->f_eir; 1619 break; 1620 case FRV_OPERAND_HINT : 1621 value = fields->f_hint; 1622 break; 1623 case FRV_OPERAND_HINT_NOT_TAKEN : 1624 value = fields->f_hint; 1625 break; 1626 case FRV_OPERAND_HINT_TAKEN : 1627 value = fields->f_hint; 1628 break; 1629 case FRV_OPERAND_LABEL16 : 1630 value = fields->f_label16; 1631 break; 1632 case FRV_OPERAND_LABEL24 : 1633 value = fields->f_label24; 1634 break; 1635 case FRV_OPERAND_LOCK : 1636 value = fields->f_lock; 1637 break; 1638 case FRV_OPERAND_PACK : 1639 value = fields->f_pack; 1640 break; 1641 case FRV_OPERAND_S10 : 1642 value = fields->f_s10; 1643 break; 1644 case FRV_OPERAND_S12 : 1645 value = fields->f_d12; 1646 break; 1647 case FRV_OPERAND_S16 : 1648 value = fields->f_s16; 1649 break; 1650 case FRV_OPERAND_S5 : 1651 value = fields->f_s5; 1652 break; 1653 case FRV_OPERAND_S6 : 1654 value = fields->f_s6; 1655 break; 1656 case FRV_OPERAND_S6_1 : 1657 value = fields->f_s6_1; 1658 break; 1659 case FRV_OPERAND_SLO16 : 1660 value = fields->f_s16; 1661 break; 1662 case FRV_OPERAND_SPR : 1663 value = fields->f_spr; 1664 break; 1665 case FRV_OPERAND_U12 : 1666 value = fields->f_u12; 1667 break; 1668 case FRV_OPERAND_U16 : 1669 value = fields->f_u16; 1670 break; 1671 case FRV_OPERAND_U6 : 1672 value = fields->f_u6; 1673 break; 1674 case FRV_OPERAND_UHI16 : 1675 value = fields->f_u16; 1676 break; 1677 case FRV_OPERAND_ULO16 : 1678 value = fields->f_u16; 1679 break; 1680 1681 default : 1682 /* xgettext:c-format */ 1683 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"), 1684 opindex); 1685 abort (); 1686 } 1687 1688 return value; 1689} 1690 1691void frv_cgen_set_int_operand 1692 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int)); 1693void frv_cgen_set_vma_operand 1694 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma)); 1695 1696/* Stuffing values in cgen_fields is handled by a collection of functions. 1697 They are distinguished by the type of the VALUE argument they accept. 1698 TODO: floating point, inlining support, remove cases where argument type 1699 not appropriate. */ 1700 1701void 1702frv_cgen_set_int_operand (cd, opindex, fields, value) 1703 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 1704 int opindex; 1705 CGEN_FIELDS * fields; 1706 int value; 1707{ 1708 switch (opindex) 1709 { 1710 case FRV_OPERAND_A0 : 1711 fields->f_A = value; 1712 break; 1713 case FRV_OPERAND_A1 : 1714 fields->f_A = value; 1715 break; 1716 case FRV_OPERAND_ACC40SI : 1717 fields->f_ACC40Si = value; 1718 break; 1719 case FRV_OPERAND_ACC40SK : 1720 fields->f_ACC40Sk = value; 1721 break; 1722 case FRV_OPERAND_ACC40UI : 1723 fields->f_ACC40Ui = value; 1724 break; 1725 case FRV_OPERAND_ACC40UK : 1726 fields->f_ACC40Uk = value; 1727 break; 1728 case FRV_OPERAND_ACCGI : 1729 fields->f_ACCGi = value; 1730 break; 1731 case FRV_OPERAND_ACCGK : 1732 fields->f_ACCGk = value; 1733 break; 1734 case FRV_OPERAND_CCI : 1735 fields->f_CCi = value; 1736 break; 1737 case FRV_OPERAND_CPRDOUBLEK : 1738 fields->f_CPRk = value; 1739 break; 1740 case FRV_OPERAND_CPRI : 1741 fields->f_CPRi = value; 1742 break; 1743 case FRV_OPERAND_CPRJ : 1744 fields->f_CPRj = value; 1745 break; 1746 case FRV_OPERAND_CPRK : 1747 fields->f_CPRk = value; 1748 break; 1749 case FRV_OPERAND_CRI : 1750 fields->f_CRi = value; 1751 break; 1752 case FRV_OPERAND_CRJ : 1753 fields->f_CRj = value; 1754 break; 1755 case FRV_OPERAND_CRJ_FLOAT : 1756 fields->f_CRj_float = value; 1757 break; 1758 case FRV_OPERAND_CRJ_INT : 1759 fields->f_CRj_int = value; 1760 break; 1761 case FRV_OPERAND_CRK : 1762 fields->f_CRk = value; 1763 break; 1764 case FRV_OPERAND_FCCI_1 : 1765 fields->f_FCCi_1 = value; 1766 break; 1767 case FRV_OPERAND_FCCI_2 : 1768 fields->f_FCCi_2 = value; 1769 break; 1770 case FRV_OPERAND_FCCI_3 : 1771 fields->f_FCCi_3 = value; 1772 break; 1773 case FRV_OPERAND_FCCK : 1774 fields->f_FCCk = value; 1775 break; 1776 case FRV_OPERAND_FRDOUBLEI : 1777 fields->f_FRi = value; 1778 break; 1779 case FRV_OPERAND_FRDOUBLEJ : 1780 fields->f_FRj = value; 1781 break; 1782 case FRV_OPERAND_FRDOUBLEK : 1783 fields->f_FRk = value; 1784 break; 1785 case FRV_OPERAND_FRI : 1786 fields->f_FRi = value; 1787 break; 1788 case FRV_OPERAND_FRINTI : 1789 fields->f_FRi = value; 1790 break; 1791 case FRV_OPERAND_FRINTIEVEN : 1792 fields->f_FRi = value; 1793 break; 1794 case FRV_OPERAND_FRINTJ : 1795 fields->f_FRj = value; 1796 break; 1797 case FRV_OPERAND_FRINTJEVEN : 1798 fields->f_FRj = value; 1799 break; 1800 case FRV_OPERAND_FRINTK : 1801 fields->f_FRk = value; 1802 break; 1803 case FRV_OPERAND_FRINTKEVEN : 1804 fields->f_FRk = value; 1805 break; 1806 case FRV_OPERAND_FRJ : 1807 fields->f_FRj = value; 1808 break; 1809 case FRV_OPERAND_FRK : 1810 fields->f_FRk = value; 1811 break; 1812 case FRV_OPERAND_FRKHI : 1813 fields->f_FRk = value; 1814 break; 1815 case FRV_OPERAND_FRKLO : 1816 fields->f_FRk = value; 1817 break; 1818 case FRV_OPERAND_GRDOUBLEK : 1819 fields->f_GRk = value; 1820 break; 1821 case FRV_OPERAND_GRI : 1822 fields->f_GRi = value; 1823 break; 1824 case FRV_OPERAND_GRJ : 1825 fields->f_GRj = value; 1826 break; 1827 case FRV_OPERAND_GRK : 1828 fields->f_GRk = value; 1829 break; 1830 case FRV_OPERAND_GRKHI : 1831 fields->f_GRk = value; 1832 break; 1833 case FRV_OPERAND_GRKLO : 1834 fields->f_GRk = value; 1835 break; 1836 case FRV_OPERAND_ICCI_1 : 1837 fields->f_ICCi_1 = value; 1838 break; 1839 case FRV_OPERAND_ICCI_2 : 1840 fields->f_ICCi_2 = value; 1841 break; 1842 case FRV_OPERAND_ICCI_3 : 1843 fields->f_ICCi_3 = value; 1844 break; 1845 case FRV_OPERAND_LI : 1846 fields->f_LI = value; 1847 break; 1848 case FRV_OPERAND_LRAD : 1849 fields->f_LRAD = value; 1850 break; 1851 case FRV_OPERAND_LRAE : 1852 fields->f_LRAE = value; 1853 break; 1854 case FRV_OPERAND_LRAS : 1855 fields->f_LRAS = value; 1856 break; 1857 case FRV_OPERAND_TLBPRL : 1858 fields->f_TLBPRL = value; 1859 break; 1860 case FRV_OPERAND_TLBPROPX : 1861 fields->f_TLBPRopx = value; 1862 break; 1863 case FRV_OPERAND_AE : 1864 fields->f_ae = value; 1865 break; 1866 case FRV_OPERAND_CCOND : 1867 fields->f_ccond = value; 1868 break; 1869 case FRV_OPERAND_COND : 1870 fields->f_cond = value; 1871 break; 1872 case FRV_OPERAND_D12 : 1873 fields->f_d12 = value; 1874 break; 1875 case FRV_OPERAND_DEBUG : 1876 fields->f_debug = value; 1877 break; 1878 case FRV_OPERAND_EIR : 1879 fields->f_eir = value; 1880 break; 1881 case FRV_OPERAND_HINT : 1882 fields->f_hint = value; 1883 break; 1884 case FRV_OPERAND_HINT_NOT_TAKEN : 1885 fields->f_hint = value; 1886 break; 1887 case FRV_OPERAND_HINT_TAKEN : 1888 fields->f_hint = value; 1889 break; 1890 case FRV_OPERAND_LABEL16 : 1891 fields->f_label16 = value; 1892 break; 1893 case FRV_OPERAND_LABEL24 : 1894 fields->f_label24 = value; 1895 break; 1896 case FRV_OPERAND_LOCK : 1897 fields->f_lock = value; 1898 break; 1899 case FRV_OPERAND_PACK : 1900 fields->f_pack = value; 1901 break; 1902 case FRV_OPERAND_S10 : 1903 fields->f_s10 = value; 1904 break; 1905 case FRV_OPERAND_S12 : 1906 fields->f_d12 = value; 1907 break; 1908 case FRV_OPERAND_S16 : 1909 fields->f_s16 = value; 1910 break; 1911 case FRV_OPERAND_S5 : 1912 fields->f_s5 = value; 1913 break; 1914 case FRV_OPERAND_S6 : 1915 fields->f_s6 = value; 1916 break; 1917 case FRV_OPERAND_S6_1 : 1918 fields->f_s6_1 = value; 1919 break; 1920 case FRV_OPERAND_SLO16 : 1921 fields->f_s16 = value; 1922 break; 1923 case FRV_OPERAND_SPR : 1924 fields->f_spr = value; 1925 break; 1926 case FRV_OPERAND_U12 : 1927 fields->f_u12 = value; 1928 break; 1929 case FRV_OPERAND_U16 : 1930 fields->f_u16 = value; 1931 break; 1932 case FRV_OPERAND_U6 : 1933 fields->f_u6 = value; 1934 break; 1935 case FRV_OPERAND_UHI16 : 1936 fields->f_u16 = value; 1937 break; 1938 case FRV_OPERAND_ULO16 : 1939 fields->f_u16 = value; 1940 break; 1941 1942 default : 1943 /* xgettext:c-format */ 1944 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"), 1945 opindex); 1946 abort (); 1947 } 1948} 1949 1950void 1951frv_cgen_set_vma_operand (cd, opindex, fields, value) 1952 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 1953 int opindex; 1954 CGEN_FIELDS * fields; 1955 bfd_vma value; 1956{ 1957 switch (opindex) 1958 { 1959 case FRV_OPERAND_A0 : 1960 fields->f_A = value; 1961 break; 1962 case FRV_OPERAND_A1 : 1963 fields->f_A = value; 1964 break; 1965 case FRV_OPERAND_ACC40SI : 1966 fields->f_ACC40Si = value; 1967 break; 1968 case FRV_OPERAND_ACC40SK : 1969 fields->f_ACC40Sk = value; 1970 break; 1971 case FRV_OPERAND_ACC40UI : 1972 fields->f_ACC40Ui = value; 1973 break; 1974 case FRV_OPERAND_ACC40UK : 1975 fields->f_ACC40Uk = value; 1976 break; 1977 case FRV_OPERAND_ACCGI : 1978 fields->f_ACCGi = value; 1979 break; 1980 case FRV_OPERAND_ACCGK : 1981 fields->f_ACCGk = value; 1982 break; 1983 case FRV_OPERAND_CCI : 1984 fields->f_CCi = value; 1985 break; 1986 case FRV_OPERAND_CPRDOUBLEK : 1987 fields->f_CPRk = value; 1988 break; 1989 case FRV_OPERAND_CPRI : 1990 fields->f_CPRi = value; 1991 break; 1992 case FRV_OPERAND_CPRJ : 1993 fields->f_CPRj = value; 1994 break; 1995 case FRV_OPERAND_CPRK : 1996 fields->f_CPRk = value; 1997 break; 1998 case FRV_OPERAND_CRI : 1999 fields->f_CRi = value; 2000 break; 2001 case FRV_OPERAND_CRJ : 2002 fields->f_CRj = value; 2003 break; 2004 case FRV_OPERAND_CRJ_FLOAT : 2005 fields->f_CRj_float = value; 2006 break; 2007 case FRV_OPERAND_CRJ_INT : 2008 fields->f_CRj_int = value; 2009 break; 2010 case FRV_OPERAND_CRK : 2011 fields->f_CRk = value; 2012 break; 2013 case FRV_OPERAND_FCCI_1 : 2014 fields->f_FCCi_1 = value; 2015 break; 2016 case FRV_OPERAND_FCCI_2 : 2017 fields->f_FCCi_2 = value; 2018 break; 2019 case FRV_OPERAND_FCCI_3 : 2020 fields->f_FCCi_3 = value; 2021 break; 2022 case FRV_OPERAND_FCCK : 2023 fields->f_FCCk = value; 2024 break; 2025 case FRV_OPERAND_FRDOUBLEI : 2026 fields->f_FRi = value; 2027 break; 2028 case FRV_OPERAND_FRDOUBLEJ : 2029 fields->f_FRj = value; 2030 break; 2031 case FRV_OPERAND_FRDOUBLEK : 2032 fields->f_FRk = value; 2033 break; 2034 case FRV_OPERAND_FRI : 2035 fields->f_FRi = value; 2036 break; 2037 case FRV_OPERAND_FRINTI : 2038 fields->f_FRi = value; 2039 break; 2040 case FRV_OPERAND_FRINTIEVEN : 2041 fields->f_FRi = value; 2042 break; 2043 case FRV_OPERAND_FRINTJ : 2044 fields->f_FRj = value; 2045 break; 2046 case FRV_OPERAND_FRINTJEVEN : 2047 fields->f_FRj = value; 2048 break; 2049 case FRV_OPERAND_FRINTK : 2050 fields->f_FRk = value; 2051 break; 2052 case FRV_OPERAND_FRINTKEVEN : 2053 fields->f_FRk = value; 2054 break; 2055 case FRV_OPERAND_FRJ : 2056 fields->f_FRj = value; 2057 break; 2058 case FRV_OPERAND_FRK : 2059 fields->f_FRk = value; 2060 break; 2061 case FRV_OPERAND_FRKHI : 2062 fields->f_FRk = value; 2063 break; 2064 case FRV_OPERAND_FRKLO : 2065 fields->f_FRk = value; 2066 break; 2067 case FRV_OPERAND_GRDOUBLEK : 2068 fields->f_GRk = value; 2069 break; 2070 case FRV_OPERAND_GRI : 2071 fields->f_GRi = value; 2072 break; 2073 case FRV_OPERAND_GRJ : 2074 fields->f_GRj = value; 2075 break; 2076 case FRV_OPERAND_GRK : 2077 fields->f_GRk = value; 2078 break; 2079 case FRV_OPERAND_GRKHI : 2080 fields->f_GRk = value; 2081 break; 2082 case FRV_OPERAND_GRKLO : 2083 fields->f_GRk = value; 2084 break; 2085 case FRV_OPERAND_ICCI_1 : 2086 fields->f_ICCi_1 = value; 2087 break; 2088 case FRV_OPERAND_ICCI_2 : 2089 fields->f_ICCi_2 = value; 2090 break; 2091 case FRV_OPERAND_ICCI_3 : 2092 fields->f_ICCi_3 = value; 2093 break; 2094 case FRV_OPERAND_LI : 2095 fields->f_LI = value; 2096 break; 2097 case FRV_OPERAND_LRAD : 2098 fields->f_LRAD = value; 2099 break; 2100 case FRV_OPERAND_LRAE : 2101 fields->f_LRAE = value; 2102 break; 2103 case FRV_OPERAND_LRAS : 2104 fields->f_LRAS = value; 2105 break; 2106 case FRV_OPERAND_TLBPRL : 2107 fields->f_TLBPRL = value; 2108 break; 2109 case FRV_OPERAND_TLBPROPX : 2110 fields->f_TLBPRopx = value; 2111 break; 2112 case FRV_OPERAND_AE : 2113 fields->f_ae = value; 2114 break; 2115 case FRV_OPERAND_CCOND : 2116 fields->f_ccond = value; 2117 break; 2118 case FRV_OPERAND_COND : 2119 fields->f_cond = value; 2120 break; 2121 case FRV_OPERAND_D12 : 2122 fields->f_d12 = value; 2123 break; 2124 case FRV_OPERAND_DEBUG : 2125 fields->f_debug = value; 2126 break; 2127 case FRV_OPERAND_EIR : 2128 fields->f_eir = value; 2129 break; 2130 case FRV_OPERAND_HINT : 2131 fields->f_hint = value; 2132 break; 2133 case FRV_OPERAND_HINT_NOT_TAKEN : 2134 fields->f_hint = value; 2135 break; 2136 case FRV_OPERAND_HINT_TAKEN : 2137 fields->f_hint = value; 2138 break; 2139 case FRV_OPERAND_LABEL16 : 2140 fields->f_label16 = value; 2141 break; 2142 case FRV_OPERAND_LABEL24 : 2143 fields->f_label24 = value; 2144 break; 2145 case FRV_OPERAND_LOCK : 2146 fields->f_lock = value; 2147 break; 2148 case FRV_OPERAND_PACK : 2149 fields->f_pack = value; 2150 break; 2151 case FRV_OPERAND_S10 : 2152 fields->f_s10 = value; 2153 break; 2154 case FRV_OPERAND_S12 : 2155 fields->f_d12 = value; 2156 break; 2157 case FRV_OPERAND_S16 : 2158 fields->f_s16 = value; 2159 break; 2160 case FRV_OPERAND_S5 : 2161 fields->f_s5 = value; 2162 break; 2163 case FRV_OPERAND_S6 : 2164 fields->f_s6 = value; 2165 break; 2166 case FRV_OPERAND_S6_1 : 2167 fields->f_s6_1 = value; 2168 break; 2169 case FRV_OPERAND_SLO16 : 2170 fields->f_s16 = value; 2171 break; 2172 case FRV_OPERAND_SPR : 2173 fields->f_spr = value; 2174 break; 2175 case FRV_OPERAND_U12 : 2176 fields->f_u12 = value; 2177 break; 2178 case FRV_OPERAND_U16 : 2179 fields->f_u16 = value; 2180 break; 2181 case FRV_OPERAND_U6 : 2182 fields->f_u6 = value; 2183 break; 2184 case FRV_OPERAND_UHI16 : 2185 fields->f_u16 = value; 2186 break; 2187 case FRV_OPERAND_ULO16 : 2188 fields->f_u16 = value; 2189 break; 2190 2191 default : 2192 /* xgettext:c-format */ 2193 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"), 2194 opindex); 2195 abort (); 2196 } 2197} 2198 2199/* Function to call before using the instruction builder tables. */ 2200 2201void 2202frv_cgen_init_ibld_table (cd) 2203 CGEN_CPU_DESC cd; 2204{ 2205 cd->insert_handlers = & frv_cgen_insert_handlers[0]; 2206 cd->extract_handlers = & frv_cgen_extract_handlers[0]; 2207 2208 cd->insert_operand = frv_cgen_insert_operand; 2209 cd->extract_operand = frv_cgen_extract_operand; 2210 2211 cd->get_int_operand = frv_cgen_get_int_operand; 2212 cd->set_int_operand = frv_cgen_set_int_operand; 2213 cd->get_vma_operand = frv_cgen_get_vma_operand; 2214 cd->set_vma_operand = frv_cgen_set_vma_operand; 2215} 2216