1/* Instruction building/extraction support for ip2k. -*- 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 "ip2k-desc.h" 34#include "ip2k-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 * ip2k_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 * 562ip2k_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 IP2K_OPERAND_ADDR16CJP : 575 errmsg = insert_normal (cd, fields->f_addr16cjp, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 12, 13, 16, total_length, buffer); 576 break; 577 case IP2K_OPERAND_ADDR16H : 578 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 7, 8, 16, total_length, buffer); 579 break; 580 case IP2K_OPERAND_ADDR16L : 581 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 7, 8, 16, total_length, buffer); 582 break; 583 case IP2K_OPERAND_ADDR16P : 584 errmsg = insert_normal (cd, fields->f_page3, 0, 0, 2, 3, 16, total_length, buffer); 585 break; 586 case IP2K_OPERAND_BITNO : 587 errmsg = insert_normal (cd, fields->f_bitno, 0, 0, 11, 3, 16, total_length, buffer); 588 break; 589 case IP2K_OPERAND_CBIT : 590 break; 591 case IP2K_OPERAND_DCBIT : 592 break; 593 case IP2K_OPERAND_FR : 594 errmsg = insert_normal (cd, fields->f_reg, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 9, 16, total_length, buffer); 595 break; 596 case IP2K_OPERAND_LIT8 : 597 errmsg = insert_normal (cd, fields->f_imm8, 0, 0, 7, 8, 16, total_length, buffer); 598 break; 599 case IP2K_OPERAND_PABITS : 600 break; 601 case IP2K_OPERAND_RETI3 : 602 errmsg = insert_normal (cd, fields->f_reti3, 0, 0, 2, 3, 16, total_length, buffer); 603 break; 604 case IP2K_OPERAND_ZBIT : 605 break; 606 607 default : 608 /* xgettext:c-format */ 609 fprintf (stderr, _("Unrecognized field %d while building insn.\n"), 610 opindex); 611 abort (); 612 } 613 614 return errmsg; 615} 616 617int ip2k_cgen_extract_operand 618 PARAMS ((CGEN_CPU_DESC, int, CGEN_EXTRACT_INFO *, CGEN_INSN_INT, 619 CGEN_FIELDS *, bfd_vma)); 620 621/* Main entry point for operand extraction. 622 The result is <= 0 for error, >0 for success. 623 ??? Actual values aren't well defined right now. 624 625 This function is basically just a big switch statement. Earlier versions 626 used tables to look up the function to use, but 627 - if the table contains both assembler and disassembler functions then 628 the disassembler contains much of the assembler and vice-versa, 629 - there's a lot of inlining possibilities as things grow, 630 - using a switch statement avoids the function call overhead. 631 632 This function could be moved into `print_insn_normal', but keeping it 633 separate makes clear the interface between `print_insn_normal' and each of 634 the handlers. */ 635 636int 637ip2k_cgen_extract_operand (cd, opindex, ex_info, insn_value, fields, pc) 638 CGEN_CPU_DESC cd; 639 int opindex; 640 CGEN_EXTRACT_INFO *ex_info; 641 CGEN_INSN_INT insn_value; 642 CGEN_FIELDS * fields; 643 bfd_vma pc; 644{ 645 /* Assume success (for those operands that are nops). */ 646 int length = 1; 647 unsigned int total_length = CGEN_FIELDS_BITSIZE (fields); 648 649 switch (opindex) 650 { 651 case IP2K_OPERAND_ADDR16CJP : 652 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 12, 13, 16, total_length, pc, & fields->f_addr16cjp); 653 break; 654 case IP2K_OPERAND_ADDR16H : 655 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 16, total_length, pc, & fields->f_imm8); 656 break; 657 case IP2K_OPERAND_ADDR16L : 658 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 16, total_length, pc, & fields->f_imm8); 659 break; 660 case IP2K_OPERAND_ADDR16P : 661 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 16, total_length, pc, & fields->f_page3); 662 break; 663 case IP2K_OPERAND_BITNO : 664 length = extract_normal (cd, ex_info, insn_value, 0, 0, 11, 3, 16, total_length, pc, & fields->f_bitno); 665 break; 666 case IP2K_OPERAND_CBIT : 667 break; 668 case IP2K_OPERAND_DCBIT : 669 break; 670 case IP2K_OPERAND_FR : 671 length = extract_normal (cd, ex_info, insn_value, 0|(1<<CGEN_IFLD_ABS_ADDR), 0, 8, 9, 16, total_length, pc, & fields->f_reg); 672 break; 673 case IP2K_OPERAND_LIT8 : 674 length = extract_normal (cd, ex_info, insn_value, 0, 0, 7, 8, 16, total_length, pc, & fields->f_imm8); 675 break; 676 case IP2K_OPERAND_PABITS : 677 break; 678 case IP2K_OPERAND_RETI3 : 679 length = extract_normal (cd, ex_info, insn_value, 0, 0, 2, 3, 16, total_length, pc, & fields->f_reti3); 680 break; 681 case IP2K_OPERAND_ZBIT : 682 break; 683 684 default : 685 /* xgettext:c-format */ 686 fprintf (stderr, _("Unrecognized field %d while decoding insn.\n"), 687 opindex); 688 abort (); 689 } 690 691 return length; 692} 693 694cgen_insert_fn * const ip2k_cgen_insert_handlers[] = 695{ 696 insert_insn_normal, 697}; 698 699cgen_extract_fn * const ip2k_cgen_extract_handlers[] = 700{ 701 extract_insn_normal, 702}; 703 704int ip2k_cgen_get_int_operand 705 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *)); 706bfd_vma ip2k_cgen_get_vma_operand 707 PARAMS ((CGEN_CPU_DESC, int, const CGEN_FIELDS *)); 708 709/* Getting values from cgen_fields is handled by a collection of functions. 710 They are distinguished by the type of the VALUE argument they return. 711 TODO: floating point, inlining support, remove cases where result type 712 not appropriate. */ 713 714int 715ip2k_cgen_get_int_operand (cd, opindex, fields) 716 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 717 int opindex; 718 const CGEN_FIELDS * fields; 719{ 720 int value; 721 722 switch (opindex) 723 { 724 case IP2K_OPERAND_ADDR16CJP : 725 value = fields->f_addr16cjp; 726 break; 727 case IP2K_OPERAND_ADDR16H : 728 value = fields->f_imm8; 729 break; 730 case IP2K_OPERAND_ADDR16L : 731 value = fields->f_imm8; 732 break; 733 case IP2K_OPERAND_ADDR16P : 734 value = fields->f_page3; 735 break; 736 case IP2K_OPERAND_BITNO : 737 value = fields->f_bitno; 738 break; 739 case IP2K_OPERAND_CBIT : 740 value = 0; 741 break; 742 case IP2K_OPERAND_DCBIT : 743 value = 0; 744 break; 745 case IP2K_OPERAND_FR : 746 value = fields->f_reg; 747 break; 748 case IP2K_OPERAND_LIT8 : 749 value = fields->f_imm8; 750 break; 751 case IP2K_OPERAND_PABITS : 752 value = 0; 753 break; 754 case IP2K_OPERAND_RETI3 : 755 value = fields->f_reti3; 756 break; 757 case IP2K_OPERAND_ZBIT : 758 value = 0; 759 break; 760 761 default : 762 /* xgettext:c-format */ 763 fprintf (stderr, _("Unrecognized field %d while getting int operand.\n"), 764 opindex); 765 abort (); 766 } 767 768 return value; 769} 770 771bfd_vma 772ip2k_cgen_get_vma_operand (cd, opindex, fields) 773 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 774 int opindex; 775 const CGEN_FIELDS * fields; 776{ 777 bfd_vma value; 778 779 switch (opindex) 780 { 781 case IP2K_OPERAND_ADDR16CJP : 782 value = fields->f_addr16cjp; 783 break; 784 case IP2K_OPERAND_ADDR16H : 785 value = fields->f_imm8; 786 break; 787 case IP2K_OPERAND_ADDR16L : 788 value = fields->f_imm8; 789 break; 790 case IP2K_OPERAND_ADDR16P : 791 value = fields->f_page3; 792 break; 793 case IP2K_OPERAND_BITNO : 794 value = fields->f_bitno; 795 break; 796 case IP2K_OPERAND_CBIT : 797 value = 0; 798 break; 799 case IP2K_OPERAND_DCBIT : 800 value = 0; 801 break; 802 case IP2K_OPERAND_FR : 803 value = fields->f_reg; 804 break; 805 case IP2K_OPERAND_LIT8 : 806 value = fields->f_imm8; 807 break; 808 case IP2K_OPERAND_PABITS : 809 value = 0; 810 break; 811 case IP2K_OPERAND_RETI3 : 812 value = fields->f_reti3; 813 break; 814 case IP2K_OPERAND_ZBIT : 815 value = 0; 816 break; 817 818 default : 819 /* xgettext:c-format */ 820 fprintf (stderr, _("Unrecognized field %d while getting vma operand.\n"), 821 opindex); 822 abort (); 823 } 824 825 return value; 826} 827 828void ip2k_cgen_set_int_operand 829 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, int)); 830void ip2k_cgen_set_vma_operand 831 PARAMS ((CGEN_CPU_DESC, int, CGEN_FIELDS *, bfd_vma)); 832 833/* Stuffing values in cgen_fields is handled by a collection of functions. 834 They are distinguished by the type of the VALUE argument they accept. 835 TODO: floating point, inlining support, remove cases where argument type 836 not appropriate. */ 837 838void 839ip2k_cgen_set_int_operand (cd, opindex, fields, value) 840 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 841 int opindex; 842 CGEN_FIELDS * fields; 843 int value; 844{ 845 switch (opindex) 846 { 847 case IP2K_OPERAND_ADDR16CJP : 848 fields->f_addr16cjp = value; 849 break; 850 case IP2K_OPERAND_ADDR16H : 851 fields->f_imm8 = value; 852 break; 853 case IP2K_OPERAND_ADDR16L : 854 fields->f_imm8 = value; 855 break; 856 case IP2K_OPERAND_ADDR16P : 857 fields->f_page3 = value; 858 break; 859 case IP2K_OPERAND_BITNO : 860 fields->f_bitno = value; 861 break; 862 case IP2K_OPERAND_CBIT : 863 break; 864 case IP2K_OPERAND_DCBIT : 865 break; 866 case IP2K_OPERAND_FR : 867 fields->f_reg = value; 868 break; 869 case IP2K_OPERAND_LIT8 : 870 fields->f_imm8 = value; 871 break; 872 case IP2K_OPERAND_PABITS : 873 break; 874 case IP2K_OPERAND_RETI3 : 875 fields->f_reti3 = value; 876 break; 877 case IP2K_OPERAND_ZBIT : 878 break; 879 880 default : 881 /* xgettext:c-format */ 882 fprintf (stderr, _("Unrecognized field %d while setting int operand.\n"), 883 opindex); 884 abort (); 885 } 886} 887 888void 889ip2k_cgen_set_vma_operand (cd, opindex, fields, value) 890 CGEN_CPU_DESC cd ATTRIBUTE_UNUSED; 891 int opindex; 892 CGEN_FIELDS * fields; 893 bfd_vma value; 894{ 895 switch (opindex) 896 { 897 case IP2K_OPERAND_ADDR16CJP : 898 fields->f_addr16cjp = value; 899 break; 900 case IP2K_OPERAND_ADDR16H : 901 fields->f_imm8 = value; 902 break; 903 case IP2K_OPERAND_ADDR16L : 904 fields->f_imm8 = value; 905 break; 906 case IP2K_OPERAND_ADDR16P : 907 fields->f_page3 = value; 908 break; 909 case IP2K_OPERAND_BITNO : 910 fields->f_bitno = value; 911 break; 912 case IP2K_OPERAND_CBIT : 913 break; 914 case IP2K_OPERAND_DCBIT : 915 break; 916 case IP2K_OPERAND_FR : 917 fields->f_reg = value; 918 break; 919 case IP2K_OPERAND_LIT8 : 920 fields->f_imm8 = value; 921 break; 922 case IP2K_OPERAND_PABITS : 923 break; 924 case IP2K_OPERAND_RETI3 : 925 fields->f_reti3 = value; 926 break; 927 case IP2K_OPERAND_ZBIT : 928 break; 929 930 default : 931 /* xgettext:c-format */ 932 fprintf (stderr, _("Unrecognized field %d while setting vma operand.\n"), 933 opindex); 934 abort (); 935 } 936} 937 938/* Function to call before using the instruction builder tables. */ 939 940void 941ip2k_cgen_init_ibld_table (cd) 942 CGEN_CPU_DESC cd; 943{ 944 cd->insert_handlers = & ip2k_cgen_insert_handlers[0]; 945 cd->extract_handlers = & ip2k_cgen_extract_handlers[0]; 946 947 cd->insert_operand = ip2k_cgen_insert_operand; 948 cd->extract_operand = ip2k_cgen_extract_operand; 949 950 cd->get_int_operand = ip2k_cgen_get_int_operand; 951 cd->set_int_operand = ip2k_cgen_set_int_operand; 952 cd->get_vma_operand = ip2k_cgen_get_vma_operand; 953 cd->set_vma_operand = ip2k_cgen_set_vma_operand; 954} 955