1 /* Opcode table for the ARC. 2 Copyright (C) 1994-2020 Free Software Foundation, Inc. 3 4 Contributed by Claudiu Zissulescu (claziss@synopsys.com) 5 6 This file is part of libopcodes. 7 8 This library is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 It is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 16 License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with this program; if not, write to the Free Software Foundation, 20 Inc., 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ 21 22 #include "sysdep.h" 23 #include <stdio.h> 24 #include "bfd.h" 25 #include "opcode/arc.h" 26 #include "opintl.h" 27 #include "libiberty.h" 28 29 /* ARC NPS400 Support: The ARC NPS400 core is an ARC700 with some custom 30 instructions. All NPS400 features are built into all ARC target builds as 31 this reduces the chances that regressions might creep in. */ 32 33 /* Insert RA register into a 32-bit opcode, with checks. */ 34 35 static unsigned long long 36 insert_ra_chk (unsigned long long insn, 37 long long value, 38 const char ** errmsg) 39 { 40 if (value == 60) 41 *errmsg = _("LP_COUNT register cannot be used as destination register"); 42 43 return insn | (value & 0x3F); 44 } 45 46 /* Insert RB register into a 32-bit opcode. */ 47 48 static unsigned long long 49 insert_rb (unsigned long long insn, 50 long long value, 51 const char ** errmsg ATTRIBUTE_UNUSED) 52 { 53 return insn | ((value & 0x07) << 24) | (((value >> 3) & 0x07) << 12); 54 } 55 56 /* Insert RB register with checks. */ 57 58 static unsigned long long 59 insert_rb_chk (unsigned long long insn, 60 long long value, 61 const char ** errmsg) 62 { 63 if (value == 60) 64 *errmsg = _("LP_COUNT register cannot be used as destination register"); 65 66 return insn | ((value & 0x07) << 24) | (((value >> 3) & 0x07) << 12); 67 } 68 69 static long long 70 extract_rb (unsigned long long insn, 71 bfd_boolean * invalid) 72 { 73 int value = (((insn >> 12) & 0x07) << 3) | ((insn >> 24) & 0x07); 74 75 if (value == 0x3e && invalid) 76 *invalid = TRUE; /* A limm operand, it should be extracted in a 77 different way. */ 78 79 return value; 80 } 81 82 static unsigned long long 83 insert_rad (unsigned long long insn, 84 long long value, 85 const char ** errmsg) 86 { 87 if (value & 0x01) 88 *errmsg = _("cannot use odd number destination register"); 89 if (value == 60) 90 *errmsg = _("LP_COUNT register cannot be used as destination register"); 91 92 return insn | (value & 0x3F); 93 } 94 95 static unsigned long long 96 insert_rcd (unsigned long long insn, 97 long long value, 98 const char ** errmsg) 99 { 100 if (value & 0x01) 101 *errmsg = _("cannot use odd number source register"); 102 103 return insn | ((value & 0x3F) << 6); 104 } 105 106 /* Dummy insert ZERO operand function. */ 107 108 static unsigned long long 109 insert_za (unsigned long long insn, 110 long long value, 111 const char ** errmsg) 112 { 113 if (value) 114 *errmsg = _("operand is not zero"); 115 return insn; 116 } 117 118 /* Insert Y-bit in bbit/br instructions. This function is called only 119 when solving fixups. */ 120 121 static unsigned long long 122 insert_Ybit (unsigned long long insn, 123 long long value, 124 const char ** errmsg ATTRIBUTE_UNUSED) 125 { 126 if (value > 0) 127 insn |= 0x08; 128 129 return insn; 130 } 131 132 /* Insert Y-bit in bbit/br instructions. This function is called only 133 when solving fixups. */ 134 135 static unsigned long long 136 insert_NYbit (unsigned long long insn, 137 long long value, 138 const char ** errmsg ATTRIBUTE_UNUSED) 139 { 140 if (value < 0) 141 insn |= 0x08; 142 143 return insn; 144 } 145 146 /* Insert H register into a 16-bit opcode. */ 147 148 static unsigned long long 149 insert_rhv1 (unsigned long long insn, 150 long long value, 151 const char ** errmsg ATTRIBUTE_UNUSED) 152 { 153 return insn |= ((value & 0x07) << 5) | ((value >> 3) & 0x07); 154 } 155 156 static long long 157 extract_rhv1 (unsigned long long insn, 158 bfd_boolean * invalid ATTRIBUTE_UNUSED) 159 { 160 int value = ((insn & 0x7) << 3) | ((insn >> 5) & 0x7); 161 162 return value; 163 } 164 165 /* Insert H register into a 16-bit opcode. */ 166 167 static unsigned long long 168 insert_rhv2 (unsigned long long insn, 169 long long value, 170 const char ** errmsg) 171 { 172 if (value == 0x1E) 173 *errmsg = _("register R30 is a limm indicator"); 174 else if (value < 0 || value > 31) 175 *errmsg = _("register out of range"); 176 return insn |= ((value & 0x07) << 5) | ((value >> 3) & 0x03); 177 } 178 179 static long long 180 extract_rhv2 (unsigned long long insn, 181 bfd_boolean * invalid ATTRIBUTE_UNUSED) 182 { 183 int value = ((insn >> 5) & 0x07) | ((insn & 0x03) << 3); 184 185 return value; 186 } 187 188 static unsigned long long 189 insert_r0 (unsigned long long insn, 190 long long value, 191 const char ** errmsg) 192 { 193 if (value != 0) 194 *errmsg = _("register must be R0"); 195 return insn; 196 } 197 198 static long long 199 extract_r0 (unsigned long long insn ATTRIBUTE_UNUSED, 200 bfd_boolean * invalid ATTRIBUTE_UNUSED) 201 { 202 return 0; 203 } 204 205 206 static unsigned long long 207 insert_r1 (unsigned long long insn, 208 long long value, 209 const char ** errmsg) 210 { 211 if (value != 1) 212 *errmsg = _("register must be R1"); 213 return insn; 214 } 215 216 static long long 217 extract_r1 (unsigned long long insn ATTRIBUTE_UNUSED, 218 bfd_boolean * invalid ATTRIBUTE_UNUSED) 219 { 220 return 1; 221 } 222 223 static unsigned long long 224 insert_r2 (unsigned long long insn, 225 long long value, 226 const char ** errmsg) 227 { 228 if (value != 2) 229 *errmsg = _("register must be R2"); 230 return insn; 231 } 232 233 static long long 234 extract_r2 (unsigned long long insn ATTRIBUTE_UNUSED, 235 bfd_boolean * invalid ATTRIBUTE_UNUSED) 236 { 237 return 2; 238 } 239 240 static unsigned long long 241 insert_r3 (unsigned long long insn, 242 long long value, 243 const char ** errmsg) 244 { 245 if (value != 3) 246 *errmsg = _("register must be R3"); 247 return insn; 248 } 249 250 static long long 251 extract_r3 (unsigned long long insn ATTRIBUTE_UNUSED, 252 bfd_boolean * invalid ATTRIBUTE_UNUSED) 253 { 254 return 3; 255 } 256 257 static unsigned long long 258 insert_sp (unsigned long long insn, 259 long long value, 260 const char ** errmsg) 261 { 262 if (value != 28) 263 *errmsg = _("register must be SP"); 264 return insn; 265 } 266 267 static long long 268 extract_sp (unsigned long long insn ATTRIBUTE_UNUSED, 269 bfd_boolean * invalid ATTRIBUTE_UNUSED) 270 { 271 return 28; 272 } 273 274 static unsigned long long 275 insert_gp (unsigned long long insn, 276 long long value, 277 const char ** errmsg) 278 { 279 if (value != 26) 280 *errmsg = _("register must be GP"); 281 return insn; 282 } 283 284 static long long 285 extract_gp (unsigned long long insn ATTRIBUTE_UNUSED, 286 bfd_boolean * invalid ATTRIBUTE_UNUSED) 287 { 288 return 26; 289 } 290 291 static unsigned long long 292 insert_pcl (unsigned long long insn, 293 long long value, 294 const char ** errmsg) 295 { 296 if (value != 63) 297 *errmsg = _("register must be PCL"); 298 return insn; 299 } 300 301 static long long 302 extract_pcl (unsigned long long insn ATTRIBUTE_UNUSED, 303 bfd_boolean * invalid ATTRIBUTE_UNUSED) 304 { 305 return 63; 306 } 307 308 static unsigned long long 309 insert_blink (unsigned long long insn, 310 long long value, 311 const char ** errmsg) 312 { 313 if (value != 31) 314 *errmsg = _("register must be BLINK"); 315 return insn; 316 } 317 318 static long long 319 extract_blink (unsigned long long insn ATTRIBUTE_UNUSED, 320 bfd_boolean * invalid ATTRIBUTE_UNUSED) 321 { 322 return 31; 323 } 324 325 static unsigned long long 326 insert_ilink1 (unsigned long long insn, 327 long long value, 328 const char ** errmsg) 329 { 330 if (value != 29) 331 *errmsg = _("register must be ILINK1"); 332 return insn; 333 } 334 335 static long long 336 extract_ilink1 (unsigned long long insn ATTRIBUTE_UNUSED, 337 bfd_boolean * invalid ATTRIBUTE_UNUSED) 338 { 339 return 29; 340 } 341 342 static unsigned long long 343 insert_ilink2 (unsigned long long insn, 344 long long value, 345 const char ** errmsg) 346 { 347 if (value != 30) 348 *errmsg = _("register must be ILINK2"); 349 return insn; 350 } 351 352 static long long 353 extract_ilink2 (unsigned long long insn ATTRIBUTE_UNUSED, 354 bfd_boolean * invalid ATTRIBUTE_UNUSED) 355 { 356 return 30; 357 } 358 359 static unsigned long long 360 insert_ras (unsigned long long insn, 361 long long value, 362 const char ** errmsg) 363 { 364 switch (value) 365 { 366 case 0: 367 case 1: 368 case 2: 369 case 3: 370 insn |= value; 371 break; 372 case 12: 373 case 13: 374 case 14: 375 case 15: 376 insn |= (value - 8); 377 break; 378 default: 379 *errmsg = _("register must be either r0-r3 or r12-r15"); 380 break; 381 } 382 return insn; 383 } 384 385 static long long 386 extract_ras (unsigned long long insn, 387 bfd_boolean * invalid ATTRIBUTE_UNUSED) 388 { 389 int value = insn & 0x07; 390 391 if (value > 3) 392 return (value + 8); 393 else 394 return value; 395 } 396 397 static unsigned long long 398 insert_rbs (unsigned long long insn, 399 long long value, 400 const char ** errmsg) 401 { 402 switch (value) 403 { 404 case 0: 405 case 1: 406 case 2: 407 case 3: 408 insn |= value << 8; 409 break; 410 case 12: 411 case 13: 412 case 14: 413 case 15: 414 insn |= ((value - 8)) << 8; 415 break; 416 default: 417 *errmsg = _("register must be either r0-r3 or r12-r15"); 418 break; 419 } 420 return insn; 421 } 422 423 static long long 424 extract_rbs (unsigned long long insn, 425 bfd_boolean * invalid ATTRIBUTE_UNUSED) 426 { 427 int value = (insn >> 8) & 0x07; 428 429 if (value > 3) 430 return (value + 8); 431 else 432 return value; 433 } 434 435 static unsigned long long 436 insert_rcs (unsigned long long insn, 437 long long value, 438 const char ** errmsg) 439 { 440 switch (value) 441 { 442 case 0: 443 case 1: 444 case 2: 445 case 3: 446 insn |= value << 5; 447 break; 448 case 12: 449 case 13: 450 case 14: 451 case 15: 452 insn |= ((value - 8)) << 5; 453 break; 454 default: 455 *errmsg = _("register must be either r0-r3 or r12-r15"); 456 break; 457 } 458 return insn; 459 } 460 461 static long long 462 extract_rcs (unsigned long long insn, 463 bfd_boolean * invalid ATTRIBUTE_UNUSED) 464 { 465 int value = (insn >> 5) & 0x07; 466 467 if (value > 3) 468 return (value + 8); 469 else 470 return value; 471 } 472 473 static unsigned long long 474 insert_simm3s (unsigned long long insn, 475 long long value, 476 const char ** errmsg) 477 { 478 int tmp = 0; 479 switch (value) 480 { 481 case -1: 482 tmp = 0x07; 483 break; 484 case 0: 485 tmp = 0x00; 486 break; 487 case 1: 488 tmp = 0x01; 489 break; 490 case 2: 491 tmp = 0x02; 492 break; 493 case 3: 494 tmp = 0x03; 495 break; 496 case 4: 497 tmp = 0x04; 498 break; 499 case 5: 500 tmp = 0x05; 501 break; 502 case 6: 503 tmp = 0x06; 504 break; 505 default: 506 *errmsg = _("accepted values are from -1 to 6"); 507 break; 508 } 509 510 insn |= tmp << 8; 511 return insn; 512 } 513 514 static long long 515 extract_simm3s (unsigned long long insn, 516 bfd_boolean * invalid ATTRIBUTE_UNUSED) 517 { 518 int value = (insn >> 8) & 0x07; 519 520 if (value == 7) 521 return -1; 522 else 523 return value; 524 } 525 526 static unsigned long long 527 insert_rrange (unsigned long long insn, 528 long long value, 529 const char ** errmsg) 530 { 531 int reg1 = (value >> 16) & 0xFFFF; 532 int reg2 = value & 0xFFFF; 533 534 if (reg1 != 13) 535 *errmsg = _("first register of the range should be r13"); 536 else if (reg2 < 13 || reg2 > 26) 537 *errmsg = _("last register of the range doesn't fit"); 538 else 539 insn |= ((reg2 - 12) & 0x0F) << 1; 540 return insn; 541 } 542 543 static long long 544 extract_rrange (unsigned long long insn, 545 bfd_boolean * invalid ATTRIBUTE_UNUSED) 546 { 547 return (insn >> 1) & 0x0F; 548 } 549 550 static unsigned long long 551 insert_r13el (unsigned long long insn, 552 long long int value, 553 const char **errmsg) 554 { 555 if (value != 13) 556 { 557 *errmsg = _("invalid register number, should be fp"); 558 return insn; 559 } 560 561 insn |= 0x02; 562 return insn; 563 } 564 565 static unsigned long long 566 insert_fpel (unsigned long long insn, 567 long long value, 568 const char ** errmsg) 569 { 570 if (value != 27) 571 { 572 *errmsg = _("invalid register number, should be fp"); 573 return insn; 574 } 575 576 insn |= 0x0100; 577 return insn; 578 } 579 580 static long long 581 extract_fpel (unsigned long long insn, 582 bfd_boolean * invalid ATTRIBUTE_UNUSED) 583 { 584 return (insn & 0x0100) ? 27 : -1; 585 } 586 587 static unsigned long long 588 insert_blinkel (unsigned long long insn, 589 long long value, 590 const char ** errmsg) 591 { 592 if (value != 31) 593 { 594 *errmsg = _("invalid register number, should be blink"); 595 return insn; 596 } 597 598 insn |= 0x0200; 599 return insn; 600 } 601 602 static long long 603 extract_blinkel (unsigned long long insn, 604 bfd_boolean * invalid ATTRIBUTE_UNUSED) 605 { 606 return (insn & 0x0200) ? 31 : -1; 607 } 608 609 static unsigned long long 610 insert_pclel (unsigned long long insn, 611 long long value, 612 const char ** errmsg) 613 { 614 if (value != 63) 615 { 616 *errmsg = _("invalid register number, should be pcl"); 617 return insn; 618 } 619 620 insn |= 0x0400; 621 return insn; 622 } 623 624 static long long 625 extract_pclel (unsigned long long insn, 626 bfd_boolean * invalid ATTRIBUTE_UNUSED) 627 { 628 return (insn & 0x0400) ? 63 : -1; 629 } 630 631 #define INSERT_W6 632 633 /* mask = 00000000000000000000111111000000 634 insn = 00011bbb000000000BBBwwwwwwDaaZZ1. */ 635 636 static unsigned long long 637 insert_w6 (unsigned long long insn, 638 long long value, 639 const char ** errmsg ATTRIBUTE_UNUSED) 640 { 641 insn |= ((value >> 0) & 0x003f) << 6; 642 643 return insn; 644 } 645 646 #define EXTRACT_W6 647 648 /* mask = 00000000000000000000111111000000. */ 649 650 static long long 651 extract_w6 (unsigned long long insn, 652 bfd_boolean * invalid ATTRIBUTE_UNUSED) 653 { 654 int value = 0; 655 656 value |= ((insn >> 6) & 0x003f) << 0; 657 658 /* Extend the sign. */ 659 int signbit = 1 << 5; 660 value = (value ^ signbit) - signbit; 661 662 return value; 663 } 664 665 #define INSERT_G_S 666 667 /* mask = 0000011100022000 668 insn = 01000ggghhhGG0HH. */ 669 670 static unsigned long long 671 insert_g_s (unsigned long long insn, 672 long long value, 673 const char ** errmsg ATTRIBUTE_UNUSED) 674 { 675 insn |= ((value >> 0) & 0x0007) << 8; 676 insn |= ((value >> 3) & 0x0003) << 3; 677 678 return insn; 679 } 680 681 #define EXTRACT_G_S 682 683 /* mask = 0000011100022000. */ 684 685 static long long 686 extract_g_s (unsigned long long insn, 687 bfd_boolean * invalid ATTRIBUTE_UNUSED) 688 { 689 int value = 0; 690 int signbit = 1 << (6 - 1); 691 692 value |= ((insn >> 8) & 0x0007) << 0; 693 value |= ((insn >> 3) & 0x0003) << 3; 694 695 /* Extend the sign. */ 696 value = (value ^ signbit) - signbit; 697 698 return value; 699 } 700 701 /* ARC NPS400 Support: See comment near head of file. */ 702 #define MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(NAME,OFFSET) \ 703 static unsigned long long \ 704 insert_nps_3bit_reg_at_##OFFSET##_##NAME \ 705 (unsigned long long insn, \ 706 long long value, \ 707 const char ** errmsg) \ 708 { \ 709 switch (value) \ 710 { \ 711 case 0: \ 712 case 1: \ 713 case 2: \ 714 case 3: \ 715 insn |= value << (OFFSET); \ 716 break; \ 717 case 12: \ 718 case 13: \ 719 case 14: \ 720 case 15: \ 721 insn |= (value - 8) << (OFFSET); \ 722 break; \ 723 default: \ 724 *errmsg = _("register must be either r0-r3 or r12-r15"); \ 725 break; \ 726 } \ 727 return insn; \ 728 } \ 729 \ 730 static long long \ 731 extract_nps_3bit_reg_at_##OFFSET##_##NAME \ 732 (unsigned long long insn, \ 733 bfd_boolean * invalid ATTRIBUTE_UNUSED) \ 734 { \ 735 int value = (insn >> (OFFSET)) & 0x07; \ 736 if (value > 3) \ 737 value += 8; \ 738 return value; \ 739 } \ 740 741 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(dst,8) 742 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(dst,24) 743 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(dst,40) 744 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(dst,56) 745 746 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(src2,5) 747 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(src2,21) 748 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(src2,37) 749 MAKE_3BIT_REG_INSERT_EXTRACT_FUNCS(src2,53) 750 751 static unsigned long long 752 insert_nps_bitop_size_2b (unsigned long long insn, 753 long long value, 754 const char ** errmsg) 755 { 756 switch (value) 757 { 758 case 1: 759 value = 0; 760 break; 761 case 2: 762 value = 1; 763 break; 764 case 4: 765 value = 2; 766 break; 767 case 8: 768 value = 3; 769 break; 770 default: 771 value = 0; 772 *errmsg = _("invalid size, should be 1, 2, 4, or 8"); 773 break; 774 } 775 776 insn |= value << 10; 777 return insn; 778 } 779 780 static long long 781 extract_nps_bitop_size_2b (unsigned long long insn, 782 bfd_boolean * invalid ATTRIBUTE_UNUSED) 783 { 784 return 1 << ((insn >> 10) & 0x3); 785 } 786 787 static unsigned long long 788 insert_nps_bitop_uimm8 (unsigned long long insn, 789 long long value, 790 const char ** errmsg ATTRIBUTE_UNUSED) 791 { 792 insn |= ((value >> 5) & 7) << 12; 793 insn |= (value & 0x1f); 794 return insn; 795 } 796 797 static long long 798 extract_nps_bitop_uimm8 (unsigned long long insn, 799 bfd_boolean * invalid ATTRIBUTE_UNUSED) 800 { 801 return (((insn >> 12) & 0x7) << 5) | (insn & 0x1f); 802 } 803 804 static unsigned long long 805 insert_nps_rflt_uimm6 (unsigned long long insn, 806 long long value, 807 const char ** errmsg) 808 { 809 switch (value) 810 { 811 case 1: 812 case 2: 813 case 4: 814 break; 815 816 default: 817 *errmsg = _("invalid immediate, must be 1, 2, or 4"); 818 value = 0; 819 } 820 821 insn |= (value << 6); 822 return insn; 823 } 824 825 static long long 826 extract_nps_rflt_uimm6 (unsigned long long insn, 827 bfd_boolean * invalid ATTRIBUTE_UNUSED) 828 { 829 return (insn >> 6) & 0x3f; 830 } 831 832 static unsigned long long 833 insert_nps_dst_pos_and_size (unsigned long long insn, 834 long long value, 835 const char ** errmsg ATTRIBUTE_UNUSED) 836 { 837 insn |= ((value & 0x1f) | (((32 - value - 1) & 0x1f) << 10)); 838 return insn; 839 } 840 841 static long long 842 extract_nps_dst_pos_and_size (unsigned long long insn, 843 bfd_boolean * invalid ATTRIBUTE_UNUSED) 844 { 845 return (insn & 0x1f); 846 } 847 848 static unsigned long long 849 insert_nps_cmem_uimm16 (unsigned long long insn, 850 long long value, 851 const char ** errmsg) 852 { 853 int top = (value >> 16) & 0xffff; 854 855 if (top != 0x0 && top != NPS_CMEM_HIGH_VALUE) 856 *errmsg = _("invalid value for CMEM ld/st immediate"); 857 insn |= (value & 0xffff); 858 return insn; 859 } 860 861 static long long 862 extract_nps_cmem_uimm16 (unsigned long long insn, 863 bfd_boolean * invalid ATTRIBUTE_UNUSED) 864 { 865 return (NPS_CMEM_HIGH_VALUE << 16) | (insn & 0xffff); 866 } 867 868 static unsigned long long 869 insert_nps_imm_offset (unsigned long long insn, 870 long long value, 871 const char ** errmsg) 872 { 873 switch (value) 874 { 875 case 0: 876 case 16: 877 case 32: 878 case 48: 879 case 64: 880 value = value >> 4; 881 break; 882 default: 883 *errmsg = _("invalid position, should be 0, 16, 32, 48 or 64."); 884 value = 0; 885 } 886 insn |= (value << 10); 887 return insn; 888 } 889 890 static long long 891 extract_nps_imm_offset (unsigned long long insn, 892 bfd_boolean * invalid ATTRIBUTE_UNUSED) 893 { 894 return ((insn >> 10) & 0x7) * 16; 895 } 896 897 static unsigned long long 898 insert_nps_imm_entry (unsigned long long insn, 899 long long value, 900 const char ** errmsg) 901 { 902 switch (value) 903 { 904 case 16: 905 value = 0; 906 break; 907 case 32: 908 value = 1; 909 break; 910 case 64: 911 value = 2; 912 break; 913 case 128: 914 value = 3; 915 break; 916 default: 917 *errmsg = _("invalid position, should be 16, 32, 64 or 128."); 918 value = 0; 919 } 920 insn |= (value << 2); 921 return insn; 922 } 923 924 static long long 925 extract_nps_imm_entry (unsigned long long insn, 926 bfd_boolean * invalid ATTRIBUTE_UNUSED) 927 { 928 int imm_entry = ((insn >> 2) & 0x7); 929 return (1 << (imm_entry + 4)); 930 } 931 932 static unsigned long long 933 insert_nps_size_16bit (unsigned long long insn, 934 long long value, 935 const char ** errmsg) 936 { 937 if ((value < 1) || (value > 64)) 938 { 939 *errmsg = _("invalid size value must be on range 1-64."); 940 value = 0; 941 } 942 value = value & 0x3f; 943 insn |= (value << 6); 944 return insn; 945 } 946 947 static long long 948 extract_nps_size_16bit (unsigned long long insn, 949 bfd_boolean * invalid ATTRIBUTE_UNUSED) 950 { 951 return ((insn & 0xfc0) >> 6) ? ((insn & 0xfc0) >> 6) : 64; 952 } 953 954 955 #define MAKE_SRC_POS_INSERT_EXTRACT_FUNCS(NAME,SHIFT) \ 956 static unsigned long long \ 957 insert_nps_##NAME##_pos (unsigned long long insn, \ 958 long long value, \ 959 const char ** errmsg) \ 960 { \ 961 switch (value) \ 962 { \ 963 case 0: \ 964 case 8: \ 965 case 16: \ 966 case 24: \ 967 value = value / 8; \ 968 break; \ 969 default: \ 970 *errmsg = _("invalid position, should be 0, 8, 16, or 24"); \ 971 value = 0; \ 972 } \ 973 insn |= (value << SHIFT); \ 974 return insn; \ 975 } \ 976 \ 977 static long long \ 978 extract_nps_##NAME##_pos (unsigned long long insn, \ 979 bfd_boolean * invalid ATTRIBUTE_UNUSED) \ 980 { \ 981 return ((insn >> SHIFT) & 0x3) * 8; \ 982 } 983 984 MAKE_SRC_POS_INSERT_EXTRACT_FUNCS (src2, 12) 985 MAKE_SRC_POS_INSERT_EXTRACT_FUNCS (src1, 10) 986 987 #define MAKE_BIAS_INSERT_EXTRACT_FUNCS(NAME,LOWER,UPPER,BITS,BIAS,SHIFT) \ 988 static unsigned long long \ 989 insert_nps_##NAME (unsigned long long insn, \ 990 long long value, \ 991 const char ** errmsg) \ 992 { \ 993 if (value < LOWER || value > UPPER) \ 994 { \ 995 *errmsg = _("invalid size, value must be " \ 996 #LOWER " to " #UPPER "."); \ 997 return insn; \ 998 } \ 999 value -= BIAS; \ 1000 insn |= (value << SHIFT); \ 1001 return insn; \ 1002 } \ 1003 \ 1004 static long long \ 1005 extract_nps_##NAME (unsigned long long insn, \ 1006 bfd_boolean * invalid ATTRIBUTE_UNUSED) \ 1007 { \ 1008 return ((insn >> SHIFT) & ((1 << BITS) - 1)) + BIAS; \ 1009 } 1010 1011 MAKE_BIAS_INSERT_EXTRACT_FUNCS (addb_size,2,32,5,1,5) 1012 MAKE_BIAS_INSERT_EXTRACT_FUNCS (andb_size,1,32,5,1,5) 1013 MAKE_BIAS_INSERT_EXTRACT_FUNCS (fxorb_size,8,32,5,8,5) 1014 MAKE_BIAS_INSERT_EXTRACT_FUNCS (wxorb_size,16,32,5,16,5) 1015 MAKE_BIAS_INSERT_EXTRACT_FUNCS (bitop_size,1,32,5,1,10) 1016 MAKE_BIAS_INSERT_EXTRACT_FUNCS (qcmp_size,1,8,3,1,9) 1017 MAKE_BIAS_INSERT_EXTRACT_FUNCS (bitop1_size,1,32,5,1,20) 1018 MAKE_BIAS_INSERT_EXTRACT_FUNCS (bitop2_size,1,32,5,1,25) 1019 MAKE_BIAS_INSERT_EXTRACT_FUNCS (hash_width,1,32,5,1,6) 1020 MAKE_BIAS_INSERT_EXTRACT_FUNCS (hash_len,1,8,3,1,2) 1021 MAKE_BIAS_INSERT_EXTRACT_FUNCS (index3,4,7,2,4,0) 1022 1023 static long long 1024 extract_nps_qcmp_m3 (unsigned long long insn, 1025 bfd_boolean * invalid) 1026 { 1027 int m3 = (insn >> 5) & 0xf; 1028 if (m3 == 0xf) 1029 *invalid = TRUE; 1030 return m3; 1031 } 1032 1033 static long long 1034 extract_nps_qcmp_m2 (unsigned long long insn, 1035 bfd_boolean * invalid) 1036 { 1037 bfd_boolean tmp_invalid = FALSE; 1038 int m2 = (insn >> 15) & 0x1; 1039 int m3 = extract_nps_qcmp_m3 (insn, &tmp_invalid); 1040 1041 if (m2 == 0 && m3 == 0xf) 1042 *invalid = TRUE; 1043 return m2; 1044 } 1045 1046 static long long 1047 extract_nps_qcmp_m1 (unsigned long long insn, 1048 bfd_boolean * invalid) 1049 { 1050 bfd_boolean tmp_invalid = FALSE; 1051 int m1 = (insn >> 14) & 0x1; 1052 int m2 = extract_nps_qcmp_m2 (insn, &tmp_invalid); 1053 int m3 = extract_nps_qcmp_m3 (insn, &tmp_invalid); 1054 1055 if (m1 == 0 && m2 == 0 && m3 == 0xf) 1056 *invalid = TRUE; 1057 return m1; 1058 } 1059 1060 static unsigned long long 1061 insert_nps_calc_entry_size (unsigned long long insn, 1062 long long value, 1063 const char ** errmsg) 1064 { 1065 unsigned pwr; 1066 1067 if (value < 1 || value > 256) 1068 { 1069 *errmsg = _("value out of range 1 - 256"); 1070 return 0; 1071 } 1072 1073 for (pwr = 0; (value & 1) == 0; value >>= 1) 1074 ++pwr; 1075 1076 if (value != 1) 1077 { 1078 *errmsg = _("value must be power of 2"); 1079 return 0; 1080 } 1081 1082 return insn | (pwr << 8); 1083 } 1084 1085 static long long 1086 extract_nps_calc_entry_size (unsigned long long insn, 1087 bfd_boolean * invalid ATTRIBUTE_UNUSED) 1088 { 1089 unsigned entry_size = (insn >> 8) & 0xf; 1090 return 1 << entry_size; 1091 } 1092 1093 static unsigned long long 1094 insert_nps_bitop_mod4 (unsigned long long insn, 1095 long long value, 1096 const char ** errmsg ATTRIBUTE_UNUSED) 1097 { 1098 return insn | ((value & 0x2) << 30) | ((value & 0x1) << 47); 1099 } 1100 1101 static long long 1102 extract_nps_bitop_mod4 (unsigned long long insn, 1103 bfd_boolean * invalid ATTRIBUTE_UNUSED) 1104 { 1105 return ((insn >> 30) & 0x2) | ((insn >> 47) & 0x1); 1106 } 1107 1108 static unsigned long long 1109 insert_nps_bitop_dst_pos3_pos4 (unsigned long long insn, 1110 long long value, 1111 const char ** errmsg ATTRIBUTE_UNUSED) 1112 { 1113 return insn | (value << 42) | (value << 37); 1114 } 1115 1116 static long long 1117 extract_nps_bitop_dst_pos3_pos4 (unsigned long long insn, 1118 bfd_boolean * invalid) 1119 { 1120 if (((insn >> 42) & 0x1f) != ((insn >> 37) & 0x1f)) 1121 *invalid = TRUE; 1122 return ((insn >> 37) & 0x1f); 1123 } 1124 1125 static unsigned long long 1126 insert_nps_bitop_ins_ext (unsigned long long insn, 1127 long long value, 1128 const char ** errmsg) 1129 { 1130 if (value < 0 || value > 28) 1131 *errmsg = _("value must be in the range 0 to 28"); 1132 return insn | (value << 20); 1133 } 1134 1135 static long long 1136 extract_nps_bitop_ins_ext (unsigned long long insn, 1137 bfd_boolean * invalid) 1138 { 1139 int value = (insn >> 20) & 0x1f; 1140 1141 if (value > 28) 1142 *invalid = TRUE; 1143 return value; 1144 } 1145 1146 #define MAKE_1BASED_INSERT_EXTRACT_FUNCS(NAME,SHIFT,UPPER,BITS) \ 1147 static unsigned long long \ 1148 insert_nps_##NAME (unsigned long long insn, \ 1149 long long value, \ 1150 const char ** errmsg) \ 1151 { \ 1152 if (value < 1 || value > UPPER) \ 1153 *errmsg = _("value must be in the range 1 to " #UPPER); \ 1154 if (value == UPPER) \ 1155 value = 0; \ 1156 return insn | (value << SHIFT); \ 1157 } \ 1158 \ 1159 static long long \ 1160 extract_nps_##NAME (unsigned long long insn, \ 1161 bfd_boolean * invalid ATTRIBUTE_UNUSED) \ 1162 { \ 1163 int value = (insn >> SHIFT) & ((1 << BITS) - 1); \ 1164 if (value == 0) \ 1165 value = UPPER; \ 1166 return value; \ 1167 } 1168 1169 MAKE_1BASED_INSERT_EXTRACT_FUNCS (field_size, 6, 8, 3) 1170 MAKE_1BASED_INSERT_EXTRACT_FUNCS (shift_factor, 9, 8, 3) 1171 MAKE_1BASED_INSERT_EXTRACT_FUNCS (bits_to_scramble, 12, 8, 3) 1172 MAKE_1BASED_INSERT_EXTRACT_FUNCS (bdlen_max_len, 5, 256, 8) 1173 MAKE_1BASED_INSERT_EXTRACT_FUNCS (bd_num_buff, 6, 8, 3) 1174 MAKE_1BASED_INSERT_EXTRACT_FUNCS (pmu_num_job, 6, 4, 2) 1175 MAKE_1BASED_INSERT_EXTRACT_FUNCS (proto_size, 16, 64, 6) 1176 1177 static unsigned long long 1178 insert_nps_min_hofs (unsigned long long insn, 1179 long long value, 1180 const char ** errmsg) 1181 { 1182 if (value < 0 || value > 240) 1183 *errmsg = _("value must be in the range 0 to 240"); 1184 if ((value % 16) != 0) 1185 *errmsg = _("value must be a multiple of 16"); 1186 value = value / 16; 1187 return insn | (value << 6); 1188 } 1189 1190 static long long 1191 extract_nps_min_hofs (unsigned long long insn, 1192 bfd_boolean * invalid ATTRIBUTE_UNUSED) 1193 { 1194 int value = (insn >> 6) & 0xF; 1195 return value * 16; 1196 } 1197 1198 #define MAKE_INSERT_NPS_ADDRTYPE(NAME, VALUE) \ 1199 static unsigned long long \ 1200 insert_nps_##NAME (unsigned long long insn, \ 1201 long long value, \ 1202 const char ** errmsg) \ 1203 { \ 1204 if (value != ARC_NPS400_ADDRTYPE_##VALUE) \ 1205 *errmsg = _("invalid address type for operand"); \ 1206 return insn; \ 1207 } \ 1208 \ 1209 static long long \ 1210 extract_nps_##NAME (unsigned long long insn ATTRIBUTE_UNUSED, \ 1211 bfd_boolean * invalid ATTRIBUTE_UNUSED) \ 1212 { \ 1213 return ARC_NPS400_ADDRTYPE_##VALUE; \ 1214 } 1215 1216 MAKE_INSERT_NPS_ADDRTYPE (bd, BD) 1217 MAKE_INSERT_NPS_ADDRTYPE (jid, JID) 1218 MAKE_INSERT_NPS_ADDRTYPE (lbd, LBD) 1219 MAKE_INSERT_NPS_ADDRTYPE (mbd, MBD) 1220 MAKE_INSERT_NPS_ADDRTYPE (sd, SD) 1221 MAKE_INSERT_NPS_ADDRTYPE (sm, SM) 1222 MAKE_INSERT_NPS_ADDRTYPE (xa, XA) 1223 MAKE_INSERT_NPS_ADDRTYPE (xd, XD) 1224 MAKE_INSERT_NPS_ADDRTYPE (cd, CD) 1225 MAKE_INSERT_NPS_ADDRTYPE (cbd, CBD) 1226 MAKE_INSERT_NPS_ADDRTYPE (cjid, CJID) 1227 MAKE_INSERT_NPS_ADDRTYPE (clbd, CLBD) 1228 MAKE_INSERT_NPS_ADDRTYPE (cm, CM) 1229 MAKE_INSERT_NPS_ADDRTYPE (csd, CSD) 1230 MAKE_INSERT_NPS_ADDRTYPE (cxa, CXA) 1231 MAKE_INSERT_NPS_ADDRTYPE (cxd, CXD) 1232 1233 static unsigned long long 1234 insert_nps_rbdouble_64 (unsigned long long insn, 1235 long long value, 1236 const char ** errmsg) 1237 { 1238 if (value < 0 || value > 31) 1239 *errmsg = _("value must be in the range 0 to 31"); 1240 return insn | (value << 43) | (value << 48); 1241 } 1242 1243 1244 static long long 1245 extract_nps_rbdouble_64 (unsigned long long insn, 1246 bfd_boolean * invalid) 1247 { 1248 int value1 = (insn >> 43) & 0x1F; 1249 int value2 = (insn >> 48) & 0x1F; 1250 1251 if (value1 != value2) 1252 *invalid = TRUE; 1253 1254 return value1; 1255 } 1256 1257 static unsigned long long 1258 insert_nps_misc_imm_offset (unsigned long long insn, 1259 long long value, 1260 const char ** errmsg) 1261 { 1262 if (value & 0x3) 1263 { 1264 *errmsg = _("invalid position, should be one of: 0,4,8,...124."); 1265 value = 0; 1266 } 1267 insn |= (value << 6); 1268 return insn; 1269 } 1270 1271 static long long int 1272 extract_nps_misc_imm_offset (unsigned long long insn, 1273 bfd_boolean * invalid ATTRIBUTE_UNUSED) 1274 { 1275 return ((insn >> 8) & 0x1f) * 4; 1276 } 1277 1278 static long long int 1279 extract_uimm12_20 (unsigned long long insn ATTRIBUTE_UNUSED, 1280 bfd_boolean * invalid ATTRIBUTE_UNUSED) 1281 { 1282 int value = 0; 1283 1284 value |= ((insn >> 6) & 0x003f) << 0; 1285 value |= ((insn >> 0) & 0x003f) << 6; 1286 1287 return value; 1288 } 1289 1290 /* Include the generic extract/insert functions. Order is important 1291 as some of the functions present in the .h may be disabled via 1292 defines. */ 1293 #include "arc-fxi.h" 1294 1295 /* The flag operands table. 1296 1297 The format of the table is 1298 NAME CODE BITS SHIFT FAVAIL. */ 1299 const struct arc_flag_operand arc_flag_operands[] = 1300 { 1301 #define F_NULL 0 1302 { 0, 0, 0, 0, 0}, 1303 #define F_ALWAYS (F_NULL + 1) 1304 { "al", 0, 0, 0, 0 }, 1305 #define F_RA (F_ALWAYS + 1) 1306 { "ra", 0, 0, 0, 0 }, 1307 #define F_EQUAL (F_RA + 1) 1308 { "eq", 1, 5, 0, 1 }, 1309 #define F_ZERO (F_EQUAL + 1) 1310 { "z", 1, 5, 0, 0 }, 1311 #define F_NOTEQUAL (F_ZERO + 1) 1312 { "ne", 2, 5, 0, 1 }, 1313 #define F_NOTZERO (F_NOTEQUAL + 1) 1314 { "nz", 2, 5, 0, 0 }, 1315 #define F_POZITIVE (F_NOTZERO + 1) 1316 { "p", 3, 5, 0, 1 }, 1317 #define F_PL (F_POZITIVE + 1) 1318 { "pl", 3, 5, 0, 0 }, 1319 #define F_NEGATIVE (F_PL + 1) 1320 { "n", 4, 5, 0, 1 }, 1321 #define F_MINUS (F_NEGATIVE + 1) 1322 { "mi", 4, 5, 0, 0 }, 1323 #define F_CARRY (F_MINUS + 1) 1324 { "c", 5, 5, 0, 1 }, 1325 #define F_CARRYSET (F_CARRY + 1) 1326 { "cs", 5, 5, 0, 0 }, 1327 #define F_LOWER (F_CARRYSET + 1) 1328 { "lo", 5, 5, 0, 0 }, 1329 #define F_CARRYCLR (F_LOWER + 1) 1330 { "cc", 6, 5, 0, 0 }, 1331 #define F_NOTCARRY (F_CARRYCLR + 1) 1332 { "nc", 6, 5, 0, 1 }, 1333 #define F_HIGHER (F_NOTCARRY + 1) 1334 { "hs", 6, 5, 0, 0 }, 1335 #define F_OVERFLOWSET (F_HIGHER + 1) 1336 { "vs", 7, 5, 0, 0 }, 1337 #define F_OVERFLOW (F_OVERFLOWSET + 1) 1338 { "v", 7, 5, 0, 1 }, 1339 #define F_NOTOVERFLOW (F_OVERFLOW + 1) 1340 { "nv", 8, 5, 0, 1 }, 1341 #define F_OVERFLOWCLR (F_NOTOVERFLOW + 1) 1342 { "vc", 8, 5, 0, 0 }, 1343 #define F_GT (F_OVERFLOWCLR + 1) 1344 { "gt", 9, 5, 0, 1 }, 1345 #define F_GE (F_GT + 1) 1346 { "ge", 10, 5, 0, 1 }, 1347 #define F_LT (F_GE + 1) 1348 { "lt", 11, 5, 0, 1 }, 1349 #define F_LE (F_LT + 1) 1350 { "le", 12, 5, 0, 1 }, 1351 #define F_HI (F_LE + 1) 1352 { "hi", 13, 5, 0, 1 }, 1353 #define F_LS (F_HI + 1) 1354 { "ls", 14, 5, 0, 1 }, 1355 #define F_PNZ (F_LS + 1) 1356 { "pnz", 15, 5, 0, 1 }, 1357 #define F_NJ (F_PNZ + 1) 1358 { "nj", 21, 5, 0, 1 }, 1359 #define F_NM (F_NJ + 1) 1360 { "nm", 23, 5, 0, 1 }, 1361 #define F_NO_T (F_NM + 1) 1362 { "nt", 24, 5, 0, 1 }, 1363 1364 /* FLAG. */ 1365 #define F_FLAG (F_NO_T + 1) 1366 { "f", 1, 1, 15, 1 }, 1367 #define F_FFAKE (F_FLAG + 1) 1368 { "f", 0, 0, 0, 1 }, 1369 1370 /* Delay slot. */ 1371 #define F_ND (F_FFAKE + 1) 1372 { "nd", 0, 1, 5, 0 }, 1373 #define F_D (F_ND + 1) 1374 { "d", 1, 1, 5, 1 }, 1375 #define F_DFAKE (F_D + 1) 1376 { "d", 0, 0, 0, 1 }, 1377 #define F_DNZ_ND (F_DFAKE + 1) 1378 { "nd", 0, 1, 16, 0 }, 1379 #define F_DNZ_D (F_DNZ_ND + 1) 1380 { "d", 1, 1, 16, 1 }, 1381 1382 /* Data size. */ 1383 #define F_SIZEB1 (F_DNZ_D + 1) 1384 { "b", 1, 2, 1, 1 }, 1385 #define F_SIZEB7 (F_SIZEB1 + 1) 1386 { "b", 1, 2, 7, 1 }, 1387 #define F_SIZEB17 (F_SIZEB7 + 1) 1388 { "b", 1, 2, 17, 1 }, 1389 #define F_SIZEW1 (F_SIZEB17 + 1) 1390 { "w", 2, 2, 1, 0 }, 1391 #define F_SIZEW7 (F_SIZEW1 + 1) 1392 { "w", 2, 2, 7, 0 }, 1393 #define F_SIZEW17 (F_SIZEW7 + 1) 1394 { "w", 2, 2, 17, 0 }, 1395 1396 /* Sign extension. */ 1397 #define F_SIGN6 (F_SIZEW17 + 1) 1398 { "x", 1, 1, 6, 1 }, 1399 #define F_SIGN16 (F_SIGN6 + 1) 1400 { "x", 1, 1, 16, 1 }, 1401 #define F_SIGNX (F_SIGN16 + 1) 1402 { "x", 0, 0, 0, 1 }, 1403 1404 /* Address write-back modes. */ 1405 #define F_A3 (F_SIGNX + 1) 1406 { "a", 1, 2, 3, 0 }, 1407 #define F_A9 (F_A3 + 1) 1408 { "a", 1, 2, 9, 0 }, 1409 #define F_A22 (F_A9 + 1) 1410 { "a", 1, 2, 22, 0 }, 1411 #define F_AW3 (F_A22 + 1) 1412 { "aw", 1, 2, 3, 1 }, 1413 #define F_AW9 (F_AW3 + 1) 1414 { "aw", 1, 2, 9, 1 }, 1415 #define F_AW22 (F_AW9 + 1) 1416 { "aw", 1, 2, 22, 1 }, 1417 #define F_AB3 (F_AW22 + 1) 1418 { "ab", 2, 2, 3, 1 }, 1419 #define F_AB9 (F_AB3 + 1) 1420 { "ab", 2, 2, 9, 1 }, 1421 #define F_AB22 (F_AB9 + 1) 1422 { "ab", 2, 2, 22, 1 }, 1423 #define F_AS3 (F_AB22 + 1) 1424 { "as", 3, 2, 3, 1 }, 1425 #define F_AS9 (F_AS3 + 1) 1426 { "as", 3, 2, 9, 1 }, 1427 #define F_AS22 (F_AS9 + 1) 1428 { "as", 3, 2, 22, 1 }, 1429 #define F_ASFAKE (F_AS22 + 1) 1430 { "as", 0, 0, 0, 1 }, 1431 1432 /* Cache bypass. */ 1433 #define F_DI5 (F_ASFAKE + 1) 1434 { "di", 1, 1, 5, 1 }, 1435 #define F_DI11 (F_DI5 + 1) 1436 { "di", 1, 1, 11, 1 }, 1437 #define F_DI14 (F_DI11 + 1) 1438 { "di", 1, 1, 14, 1 }, 1439 #define F_DI15 (F_DI14 + 1) 1440 { "di", 1, 1, 15, 1 }, 1441 1442 /* ARCv2 specific. */ 1443 #define F_NT (F_DI15 + 1) 1444 { "nt", 0, 1, 3, 1}, 1445 #define F_T (F_NT + 1) 1446 { "t", 1, 1, 3, 1}, 1447 #define F_H1 (F_T + 1) 1448 { "h", 2, 2, 1, 1 }, 1449 #define F_H7 (F_H1 + 1) 1450 { "h", 2, 2, 7, 1 }, 1451 #define F_H17 (F_H7 + 1) 1452 { "h", 2, 2, 17, 1 }, 1453 #define F_SIZED (F_H17 + 1) 1454 { "dd", 8, 0, 0, 0 }, /* Fake. */ 1455 1456 /* Fake Flags. */ 1457 #define F_NE (F_SIZED + 1) 1458 { "ne", 0, 0, 0, 1 }, 1459 1460 /* ARC NPS400 Support: See comment near head of file. */ 1461 #define F_NPS_CL (F_NE + 1) 1462 { "cl", 0, 0, 0, 1 }, 1463 1464 #define F_NPS_NA (F_NPS_CL + 1) 1465 { "na", 1, 1, 9, 1 }, 1466 1467 #define F_NPS_SR (F_NPS_NA + 1) 1468 { "s", 1, 1, 13, 1 }, 1469 1470 #define F_NPS_M (F_NPS_SR + 1) 1471 { "m", 1, 1, 7, 1 }, 1472 1473 #define F_NPS_FLAG (F_NPS_M + 1) 1474 { "f", 1, 1, 20, 1 }, 1475 1476 #define F_NPS_R (F_NPS_FLAG + 1) 1477 { "r", 1, 1, 15, 1 }, 1478 1479 #define F_NPS_RW (F_NPS_R + 1) 1480 { "rw", 0, 1, 7, 1 }, 1481 1482 #define F_NPS_RD (F_NPS_RW + 1) 1483 { "rd", 1, 1, 7, 1 }, 1484 1485 #define F_NPS_WFT (F_NPS_RD + 1) 1486 { "wft", 0, 0, 0, 1 }, 1487 1488 #define F_NPS_IE1 (F_NPS_WFT + 1) 1489 { "ie1", 1, 2, 8, 1 }, 1490 1491 #define F_NPS_IE2 (F_NPS_IE1 + 1) 1492 { "ie2", 2, 2, 8, 1 }, 1493 1494 #define F_NPS_IE12 (F_NPS_IE2 + 1) 1495 { "ie12", 3, 2, 8, 1 }, 1496 1497 #define F_NPS_SYNC_RD (F_NPS_IE12 + 1) 1498 { "rd", 0, 1, 6, 1 }, 1499 1500 #define F_NPS_SYNC_WR (F_NPS_SYNC_RD + 1) 1501 { "wr", 1, 1, 6, 1 }, 1502 1503 #define F_NPS_HWS_OFF (F_NPS_SYNC_WR + 1) 1504 { "off", 0, 0, 0, 1 }, 1505 1506 #define F_NPS_HWS_RESTORE (F_NPS_HWS_OFF + 1) 1507 { "restore", 0, 0, 0, 1 }, 1508 1509 #define F_NPS_SX (F_NPS_HWS_RESTORE + 1) 1510 { "sx", 1, 1, 14, 1 }, 1511 1512 #define F_NPS_AR (F_NPS_SX + 1) 1513 { "ar", 0, 1, 0, 1 }, 1514 1515 #define F_NPS_AL (F_NPS_AR + 1) 1516 { "al", 1, 1, 0, 1 }, 1517 1518 #define F_NPS_S (F_NPS_AL + 1) 1519 { "s", 0, 0, 0, 1 }, 1520 1521 #define F_NPS_ZNCV_RD (F_NPS_S + 1) 1522 { "rd", 0, 1, 15, 1 }, 1523 1524 #define F_NPS_ZNCV_WR (F_NPS_ZNCV_RD + 1) 1525 { "wr", 1, 1, 15, 1 }, 1526 1527 #define F_NPS_P0 (F_NPS_ZNCV_WR + 1) 1528 { "p0", 0, 0, 0, 1 }, 1529 1530 #define F_NPS_P1 (F_NPS_P0 + 1) 1531 { "p1", 0, 0, 0, 1 }, 1532 1533 #define F_NPS_P2 (F_NPS_P1 + 1) 1534 { "p2", 0, 0, 0, 1 }, 1535 1536 #define F_NPS_P3 (F_NPS_P2 + 1) 1537 { "p3", 0, 0, 0, 1 }, 1538 1539 #define F_NPS_LDBIT_DI (F_NPS_P3 + 1) 1540 { "di", 0, 0, 0, 1 }, 1541 1542 #define F_NPS_LDBIT_CL1 (F_NPS_LDBIT_DI + 1) 1543 { "cl", 1, 1, 6, 1 }, 1544 1545 #define F_NPS_LDBIT_CL2 (F_NPS_LDBIT_CL1 + 1) 1546 { "cl", 1, 1, 16, 1 }, 1547 1548 #define F_NPS_LDBIT_X2_1 (F_NPS_LDBIT_CL2 + 1) 1549 { "x2", 1, 2, 9, 1 }, 1550 1551 #define F_NPS_LDBIT_X2_2 (F_NPS_LDBIT_X2_1 + 1) 1552 { "x2", 1, 2, 22, 1 }, 1553 1554 #define F_NPS_LDBIT_X4_1 (F_NPS_LDBIT_X2_2 + 1) 1555 { "x4", 2, 2, 9, 1 }, 1556 1557 #define F_NPS_LDBIT_X4_2 (F_NPS_LDBIT_X4_1 + 1) 1558 { "x4", 2, 2, 22, 1 }, 1559 1560 #define F_NPS_CORE (F_NPS_LDBIT_X4_2 + 1) 1561 { "core", 1, 3, 6, 1 }, 1562 1563 #define F_NPS_CLSR (F_NPS_CORE + 1) 1564 { "clsr", 2, 3, 6, 1 }, 1565 1566 #define F_NPS_ALL (F_NPS_CLSR + 1) 1567 { "all", 3, 3, 6, 1 }, 1568 1569 #define F_NPS_GIC (F_NPS_ALL + 1) 1570 { "gic", 4, 3, 6, 1 }, 1571 1572 #define F_NPS_RSPI_GIC (F_NPS_GIC + 1) 1573 { "gic", 5, 3, 6, 1 }, 1574 }; 1575 1576 const unsigned arc_num_flag_operands = ARRAY_SIZE (arc_flag_operands); 1577 1578 /* Table of the flag classes. 1579 1580 The format of the table is 1581 CLASS {FLAG_CODE}. */ 1582 const struct arc_flag_class arc_flag_classes[] = 1583 { 1584 #define C_EMPTY 0 1585 { F_CLASS_NONE, { F_NULL } }, 1586 1587 #define C_CC_EQ (C_EMPTY + 1) 1588 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_EQUAL, F_NULL} }, 1589 1590 #define C_CC_GE (C_CC_EQ + 1) 1591 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_GE, F_NULL} }, 1592 1593 #define C_CC_GT (C_CC_GE + 1) 1594 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_GT, F_NULL} }, 1595 1596 #define C_CC_HI (C_CC_GT + 1) 1597 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_HI, F_NULL} }, 1598 1599 #define C_CC_HS (C_CC_HI + 1) 1600 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_NOTCARRY, F_NULL} }, 1601 1602 #define C_CC_LE (C_CC_HS + 1) 1603 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_LE, F_NULL} }, 1604 1605 #define C_CC_LO (C_CC_LE + 1) 1606 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_CARRY, F_NULL} }, 1607 1608 #define C_CC_LS (C_CC_LO + 1) 1609 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_LS, F_NULL} }, 1610 1611 #define C_CC_LT (C_CC_LS + 1) 1612 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_LT, F_NULL} }, 1613 1614 #define C_CC_NE (C_CC_LT + 1) 1615 {F_CLASS_IMPLICIT | F_CLASS_COND, {F_NOTEQUAL, F_NULL} }, 1616 1617 #define C_AA_AB (C_CC_NE + 1) 1618 {F_CLASS_IMPLICIT | F_CLASS_WB, {F_AB3, F_NULL} }, 1619 1620 #define C_AA_AW (C_AA_AB + 1) 1621 {F_CLASS_IMPLICIT | F_CLASS_WB, {F_AW3, F_NULL} }, 1622 1623 #define C_ZZ_D (C_AA_AW + 1) 1624 {F_CLASS_IMPLICIT | F_CLASS_ZZ, {F_SIZED, F_NULL} }, 1625 1626 #define C_ZZ_H (C_ZZ_D + 1) 1627 {F_CLASS_IMPLICIT | F_CLASS_ZZ, {F_H1, F_NULL} }, 1628 1629 #define C_ZZ_B (C_ZZ_H + 1) 1630 {F_CLASS_IMPLICIT | F_CLASS_ZZ, {F_SIZEB1, F_NULL} }, 1631 1632 #define C_CC (C_ZZ_B + 1) 1633 { F_CLASS_OPTIONAL | F_CLASS_EXTEND | F_CLASS_COND, 1634 { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, 1635 F_NOTZERO, F_POZITIVE, F_PL, F_NEGATIVE, F_MINUS, 1636 F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 1637 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, 1638 F_NOTOVERFLOW, F_OVERFLOWCLR, F_GT, F_GE, F_LT, 1639 F_LE, F_HI, F_LS, F_PNZ, F_NJ, F_NM, F_NO_T, F_NULL } }, 1640 1641 #define C_AA_ADDR3 (C_CC + 1) 1642 #define C_AA27 (C_CC + 1) 1643 { F_CLASS_OPTIONAL | F_CLASS_WB, { F_A3, F_AW3, F_AB3, F_AS3, F_NULL } }, 1644 #define C_AA_ADDR9 (C_AA_ADDR3 + 1) 1645 #define C_AA21 (C_AA_ADDR3 + 1) 1646 { F_CLASS_OPTIONAL | F_CLASS_WB, { F_A9, F_AW9, F_AB9, F_AS9, F_NULL } }, 1647 #define C_AA_ADDR22 (C_AA_ADDR9 + 1) 1648 #define C_AA8 (C_AA_ADDR9 + 1) 1649 { F_CLASS_OPTIONAL | F_CLASS_WB, { F_A22, F_AW22, F_AB22, F_AS22, F_NULL } }, 1650 1651 #define C_F (C_AA_ADDR22 + 1) 1652 { F_CLASS_OPTIONAL, { F_FLAG, F_NULL } }, 1653 #define C_FHARD (C_F + 1) 1654 { F_CLASS_OPTIONAL, { F_FFAKE, F_NULL } }, 1655 1656 #define C_T (C_FHARD + 1) 1657 { F_CLASS_OPTIONAL, { F_NT, F_T, F_NULL } }, 1658 #define C_D (C_T + 1) 1659 { F_CLASS_OPTIONAL, { F_ND, F_D, F_NULL } }, 1660 #define C_DNZ_D (C_D + 1) 1661 { F_CLASS_OPTIONAL, { F_DNZ_ND, F_DNZ_D, F_NULL } }, 1662 1663 #define C_DHARD (C_DNZ_D + 1) 1664 { F_CLASS_OPTIONAL, { F_DFAKE, F_NULL } }, 1665 1666 #define C_DI20 (C_DHARD + 1) 1667 { F_CLASS_OPTIONAL, { F_DI11, F_NULL }}, 1668 #define C_DI14 (C_DI20 + 1) 1669 { F_CLASS_OPTIONAL, { F_DI14, F_NULL }}, 1670 #define C_DI16 (C_DI14 + 1) 1671 { F_CLASS_OPTIONAL, { F_DI15, F_NULL }}, 1672 #define C_DI26 (C_DI16 + 1) 1673 { F_CLASS_OPTIONAL, { F_DI5, F_NULL }}, 1674 1675 #define C_X25 (C_DI26 + 1) 1676 { F_CLASS_OPTIONAL, { F_SIGN6, F_NULL }}, 1677 #define C_X15 (C_X25 + 1) 1678 { F_CLASS_OPTIONAL, { F_SIGN16, F_NULL }}, 1679 #define C_XHARD (C_X15 + 1) 1680 #define C_X (C_X15 + 1) 1681 { F_CLASS_OPTIONAL, { F_SIGNX, F_NULL }}, 1682 1683 #define C_ZZ13 (C_X + 1) 1684 { F_CLASS_OPTIONAL, { F_SIZEB17, F_SIZEW17, F_H17, F_NULL}}, 1685 #define C_ZZ23 (C_ZZ13 + 1) 1686 { F_CLASS_OPTIONAL, { F_SIZEB7, F_SIZEW7, F_H7, F_NULL}}, 1687 #define C_ZZ29 (C_ZZ23 + 1) 1688 { F_CLASS_OPTIONAL, { F_SIZEB1, F_SIZEW1, F_H1, F_NULL}}, 1689 1690 #define C_AS (C_ZZ29 + 1) 1691 { F_CLASS_OPTIONAL, { F_ASFAKE, F_NULL}}, 1692 1693 #define C_NE (C_AS + 1) 1694 { F_CLASS_REQUIRED, { F_NE, F_NULL}}, 1695 1696 /* ARC NPS400 Support: See comment near head of file. */ 1697 #define C_NPS_CL (C_NE + 1) 1698 { F_CLASS_REQUIRED, { F_NPS_CL, F_NULL}}, 1699 1700 #define C_NPS_NA (C_NPS_CL + 1) 1701 { F_CLASS_OPTIONAL, { F_NPS_NA, F_NULL}}, 1702 1703 #define C_NPS_SR (C_NPS_NA + 1) 1704 { F_CLASS_OPTIONAL, { F_NPS_SR, F_NULL}}, 1705 1706 #define C_NPS_M (C_NPS_SR + 1) 1707 { F_CLASS_OPTIONAL, { F_NPS_M, F_NULL}}, 1708 1709 #define C_NPS_F (C_NPS_M + 1) 1710 { F_CLASS_OPTIONAL, { F_NPS_FLAG, F_NULL}}, 1711 1712 #define C_NPS_R (C_NPS_F + 1) 1713 { F_CLASS_OPTIONAL, { F_NPS_R, F_NULL}}, 1714 1715 #define C_NPS_SCHD_RW (C_NPS_R + 1) 1716 { F_CLASS_REQUIRED, { F_NPS_RW, F_NPS_RD, F_NULL}}, 1717 1718 #define C_NPS_SCHD_TRIG (C_NPS_SCHD_RW + 1) 1719 { F_CLASS_REQUIRED, { F_NPS_WFT, F_NULL}}, 1720 1721 #define C_NPS_SCHD_IE (C_NPS_SCHD_TRIG + 1) 1722 { F_CLASS_OPTIONAL, { F_NPS_IE1, F_NPS_IE2, F_NPS_IE12, F_NULL}}, 1723 1724 #define C_NPS_SYNC (C_NPS_SCHD_IE + 1) 1725 { F_CLASS_REQUIRED, { F_NPS_SYNC_RD, F_NPS_SYNC_WR, F_NULL}}, 1726 1727 #define C_NPS_HWS_OFF (C_NPS_SYNC + 1) 1728 { F_CLASS_REQUIRED, { F_NPS_HWS_OFF, F_NULL}}, 1729 1730 #define C_NPS_HWS_RESTORE (C_NPS_HWS_OFF + 1) 1731 { F_CLASS_REQUIRED, { F_NPS_HWS_RESTORE, F_NULL}}, 1732 1733 #define C_NPS_SX (C_NPS_HWS_RESTORE + 1) 1734 { F_CLASS_OPTIONAL, { F_NPS_SX, F_NULL}}, 1735 1736 #define C_NPS_AR_AL (C_NPS_SX + 1) 1737 { F_CLASS_REQUIRED, { F_NPS_AR, F_NPS_AL, F_NULL}}, 1738 1739 #define C_NPS_S (C_NPS_AR_AL + 1) 1740 { F_CLASS_REQUIRED, { F_NPS_S, F_NULL}}, 1741 1742 #define C_NPS_ZNCV (C_NPS_S + 1) 1743 { F_CLASS_REQUIRED, { F_NPS_ZNCV_RD, F_NPS_ZNCV_WR, F_NULL}}, 1744 1745 #define C_NPS_P0 (C_NPS_ZNCV + 1) 1746 { F_CLASS_REQUIRED, { F_NPS_P0, F_NULL }}, 1747 1748 #define C_NPS_P1 (C_NPS_P0 + 1) 1749 { F_CLASS_REQUIRED, { F_NPS_P1, F_NULL }}, 1750 1751 #define C_NPS_P2 (C_NPS_P1 + 1) 1752 { F_CLASS_REQUIRED, { F_NPS_P2, F_NULL }}, 1753 1754 #define C_NPS_P3 (C_NPS_P2 + 1) 1755 { F_CLASS_REQUIRED, { F_NPS_P3, F_NULL }}, 1756 1757 #define C_NPS_LDBIT_DI (C_NPS_P3 + 1) 1758 { F_CLASS_REQUIRED, { F_NPS_LDBIT_DI, F_NULL }}, 1759 1760 #define C_NPS_LDBIT_CL1 (C_NPS_LDBIT_DI + 1) 1761 { F_CLASS_OPTIONAL, { F_NPS_LDBIT_CL1, F_NULL }}, 1762 1763 #define C_NPS_LDBIT_CL2 (C_NPS_LDBIT_CL1 + 1) 1764 { F_CLASS_OPTIONAL, { F_NPS_LDBIT_CL2, F_NULL }}, 1765 1766 #define C_NPS_LDBIT_X_1 (C_NPS_LDBIT_CL2 + 1) 1767 { F_CLASS_OPTIONAL, { F_NPS_LDBIT_X2_1, F_NPS_LDBIT_X4_1, F_NULL }}, 1768 1769 #define C_NPS_LDBIT_X_2 (C_NPS_LDBIT_X_1 + 1) 1770 { F_CLASS_OPTIONAL, { F_NPS_LDBIT_X2_2, F_NPS_LDBIT_X4_2, F_NULL }}, 1771 1772 #define C_NPS_CORE (C_NPS_LDBIT_X_2 + 1) 1773 { F_CLASS_REQUIRED, { F_NPS_CORE, F_NULL}}, 1774 1775 #define C_NPS_CLSR (C_NPS_CORE + 1) 1776 { F_CLASS_REQUIRED, { F_NPS_CLSR, F_NULL}}, 1777 1778 #define C_NPS_ALL (C_NPS_CLSR + 1) 1779 { F_CLASS_REQUIRED, { F_NPS_ALL, F_NULL}}, 1780 1781 #define C_NPS_GIC (C_NPS_ALL + 1) 1782 { F_CLASS_REQUIRED, { F_NPS_GIC, F_NULL}}, 1783 1784 #define C_NPS_RSPI_GIC (C_NPS_GIC + 1) 1785 { F_CLASS_REQUIRED, { F_NPS_RSPI_GIC, F_NULL}}, 1786 }; 1787 1788 const unsigned char flags_none[] = { 0 }; 1789 const unsigned char flags_f[] = { C_F }; 1790 const unsigned char flags_cc[] = { C_CC }; 1791 const unsigned char flags_ccf[] = { C_CC, C_F }; 1792 1793 /* The operands table. 1794 1795 The format of the operands table is: 1796 1797 BITS SHIFT DEFAULT_RELOC FLAGS INSERT_FUN EXTRACT_FUN. */ 1798 const struct arc_operand arc_operands[] = 1799 { 1800 /* The fields are bits, shift, insert, extract, flags. The zero 1801 index is used to indicate end-of-list. */ 1802 #define UNUSED 0 1803 { 0, 0, 0, 0, 0, 0 }, 1804 1805 #define IGNORED (UNUSED + 1) 1806 { 0, 0, 0, ARC_OPERAND_IGNORE | ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 0, 0 }, 1807 1808 /* The plain integer register fields. Used by 32 bit 1809 instructions. */ 1810 #define RA (IGNORED + 1) 1811 { 6, 0, 0, ARC_OPERAND_IR, 0, 0 }, 1812 #define RA_CHK (RA + 1) 1813 { 6, 0, 0, ARC_OPERAND_IR, insert_ra_chk, 0 }, 1814 #define RB (RA_CHK + 1) 1815 { 6, 12, 0, ARC_OPERAND_IR, insert_rb, extract_rb }, 1816 #define RB_CHK (RB + 1) 1817 { 6, 12, 0, ARC_OPERAND_IR, insert_rb_chk, extract_rb }, 1818 #define RC (RB_CHK + 1) 1819 { 6, 6, 0, ARC_OPERAND_IR, 0, 0 }, 1820 #define RBdup (RC + 1) 1821 { 6, 12, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE, insert_rb, extract_rb }, 1822 1823 #define RAD (RBdup + 1) 1824 { 6, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_TRUNCATE, insert_rad, 0 }, 1825 #define RAD_CHK (RAD + 1) 1826 { 6, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_TRUNCATE, insert_rad, 0 }, 1827 #define RCD (RAD_CHK + 1) 1828 { 6, 6, 0, ARC_OPERAND_IR | ARC_OPERAND_TRUNCATE, insert_rcd, 0 }, 1829 1830 /* The plain integer register fields. Used by short 1831 instructions. */ 1832 #define RA16 (RCD + 1) 1833 #define RA_S (RCD + 1) 1834 { 4, 0, 0, ARC_OPERAND_IR, insert_ras, extract_ras }, 1835 #define RB16 (RA16 + 1) 1836 #define RB_S (RA16 + 1) 1837 { 4, 8, 0, ARC_OPERAND_IR, insert_rbs, extract_rbs }, 1838 #define RB16dup (RB16 + 1) 1839 #define RB_Sdup (RB16 + 1) 1840 { 4, 8, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE, insert_rbs, extract_rbs }, 1841 #define RC16 (RB16dup + 1) 1842 #define RC_S (RB16dup + 1) 1843 { 4, 5, 0, ARC_OPERAND_IR, insert_rcs, extract_rcs }, 1844 #define R6H (RC16 + 1) /* 6bit register field 'h' used 1845 by V1 cpus. */ 1846 { 6, 5, 0, ARC_OPERAND_IR, insert_rhv1, extract_rhv1 }, 1847 #define R5H (R6H + 1) /* 5bit register field 'h' used 1848 by V2 cpus. */ 1849 #define RH_S (R6H + 1) /* 5bit register field 'h' used 1850 by V2 cpus. */ 1851 { 5, 5, 0, ARC_OPERAND_IR, insert_rhv2, extract_rhv2 }, 1852 #define R5Hdup (R5H + 1) 1853 #define RH_Sdup (R5H + 1) 1854 { 5, 5, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE, 1855 insert_rhv2, extract_rhv2 }, 1856 1857 #define RG (R5Hdup + 1) 1858 #define G_S (R5Hdup + 1) 1859 { 5, 5, 0, ARC_OPERAND_IR, insert_g_s, extract_g_s }, 1860 1861 /* Fix registers. */ 1862 #define R0 (RG + 1) 1863 #define R0_S (RG + 1) 1864 { 0, 0, 0, ARC_OPERAND_IR, insert_r0, extract_r0 }, 1865 #define R1 (R0 + 1) 1866 #define R1_S (R0 + 1) 1867 { 1, 0, 0, ARC_OPERAND_IR, insert_r1, extract_r1 }, 1868 #define R2 (R1 + 1) 1869 #define R2_S (R1 + 1) 1870 { 2, 0, 0, ARC_OPERAND_IR, insert_r2, extract_r2 }, 1871 #define R3 (R2 + 1) 1872 #define R3_S (R2 + 1) 1873 { 2, 0, 0, ARC_OPERAND_IR, insert_r3, extract_r3 }, 1874 #define RSP (R3 + 1) 1875 #define SP_S (R3 + 1) 1876 { 5, 0, 0, ARC_OPERAND_IR, insert_sp, extract_sp }, 1877 #define SPdup (RSP + 1) 1878 #define SP_Sdup (RSP + 1) 1879 { 5, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE, insert_sp, extract_sp }, 1880 #define GP (SPdup + 1) 1881 #define GP_S (SPdup + 1) 1882 { 5, 0, 0, ARC_OPERAND_IR, insert_gp, extract_gp }, 1883 1884 #define PCL_S (GP + 1) 1885 { 1, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, insert_pcl, extract_pcl }, 1886 1887 #define BLINK (PCL_S + 1) 1888 #define BLINK_S (PCL_S + 1) 1889 { 5, 0, 0, ARC_OPERAND_IR, insert_blink, extract_blink }, 1890 1891 #define ILINK1 (BLINK + 1) 1892 { 5, 0, 0, ARC_OPERAND_IR, insert_ilink1, extract_ilink1 }, 1893 #define ILINK2 (ILINK1 + 1) 1894 { 5, 0, 0, ARC_OPERAND_IR, insert_ilink2, extract_ilink2 }, 1895 1896 /* Long immediate. */ 1897 #define LIMM (ILINK2 + 1) 1898 #define LIMM_S (ILINK2 + 1) 1899 { 32, 0, BFD_RELOC_ARC_32_ME, ARC_OPERAND_LIMM, insert_limm, 0 }, 1900 #define LIMMdup (LIMM + 1) 1901 { 32, 0, 0, ARC_OPERAND_LIMM | ARC_OPERAND_DUPLICATE, insert_limm, 0 }, 1902 1903 /* Special operands. */ 1904 #define ZA (LIMMdup + 1) 1905 #define ZB (LIMMdup + 1) 1906 #define ZA_S (LIMMdup + 1) 1907 #define ZB_S (LIMMdup + 1) 1908 #define ZC_S (LIMMdup + 1) 1909 { 0, 0, 0, ARC_OPERAND_UNSIGNED, insert_za, 0 }, 1910 1911 #define RRANGE_EL (ZA + 1) 1912 { 4, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK | ARC_OPERAND_TRUNCATE, 1913 insert_rrange, extract_rrange}, 1914 #define R13_EL (RRANGE_EL + 1) 1915 { 1, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_IGNORE | ARC_OPERAND_NCHK, 1916 insert_r13el, extract_rrange }, 1917 #define FP_EL (R13_EL + 1) 1918 { 1, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_IGNORE | ARC_OPERAND_NCHK, 1919 insert_fpel, extract_fpel }, 1920 #define BLINK_EL (FP_EL + 1) 1921 { 1, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_IGNORE | ARC_OPERAND_NCHK, 1922 insert_blinkel, extract_blinkel }, 1923 #define PCL_EL (BLINK_EL + 1) 1924 { 1, 0, 0, ARC_OPERAND_IR | ARC_OPERAND_IGNORE | ARC_OPERAND_NCHK, 1925 insert_pclel, extract_pclel }, 1926 1927 /* Fake operand to handle the T flag. */ 1928 #define BRAKET (PCL_EL + 1) 1929 #define BRAKETdup (PCL_EL + 1) 1930 { 0, 0, 0, ARC_OPERAND_FAKE | ARC_OPERAND_BRAKET, 0, 0 }, 1931 1932 /* Fake operand to handle the T flag. */ 1933 #define FKT_T (BRAKET + 1) 1934 { 1, 3, 0, ARC_OPERAND_FAKE, insert_Ybit, 0 }, 1935 /* Fake operand to handle the T flag. */ 1936 #define FKT_NT (FKT_T + 1) 1937 { 1, 3, 0, ARC_OPERAND_FAKE, insert_NYbit, 0 }, 1938 1939 /* UIMM6_20 mask = 00000000000000000000111111000000. */ 1940 #define UIMM6_20 (FKT_NT + 1) 1941 {6, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm6_20, extract_uimm6_20}, 1942 1943 /* Exactly like the above but used by relaxation. */ 1944 #define UIMM6_20R (UIMM6_20 + 1) 1945 {6, 0, -UIMM6_20R, ARC_OPERAND_UNSIGNED | ARC_OPERAND_PCREL, 1946 insert_uimm6_20, extract_uimm6_20}, 1947 1948 /* SIMM12_20 mask = 00000000000000000000111111222222. */ 1949 #define SIMM12_20 (UIMM6_20R + 1) 1950 {12, 0, 0, ARC_OPERAND_SIGNED, insert_simm12_20, extract_simm12_20}, 1951 1952 /* Exactly like the above but used by relaxation. */ 1953 #define SIMM12_20R (SIMM12_20 + 1) 1954 {12, 0, -SIMM12_20R, ARC_OPERAND_SIGNED | ARC_OPERAND_PCREL, 1955 insert_simm12_20, extract_simm12_20}, 1956 1957 /* UIMM12_20 mask = 00000000000000000000111111222222. */ 1958 #define UIMM12_20 (SIMM12_20R + 1) 1959 {12, 0, 0, ARC_OPERAND_UNSIGNED, insert_simm12_20, extract_uimm12_20}, 1960 1961 /* SIMM3_5_S mask = 0000011100000000. */ 1962 #define SIMM3_5_S (UIMM12_20 + 1) 1963 {3, 0, 0, ARC_OPERAND_SIGNED | ARC_OPERAND_NCHK, 1964 insert_simm3s, extract_simm3s}, 1965 1966 /* UIMM7_A32_11_S mask = 0000000000011111. */ 1967 #define UIMM7_A32_11_S (SIMM3_5_S + 1) 1968 {7, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED32 1969 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_IGNORE, insert_uimm7_a32_11_s, 1970 extract_uimm7_a32_11_s}, 1971 1972 /* The same as above but used by relaxation. */ 1973 #define UIMM7_A32_11R_S (UIMM7_A32_11_S + 1) 1974 {7, 0, -UIMM7_A32_11R_S, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED32 1975 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_IGNORE | ARC_OPERAND_PCREL, 1976 insert_uimm7_a32_11_s, extract_uimm7_a32_11_s}, 1977 1978 /* UIMM7_9_S mask = 0000000001111111. */ 1979 #define UIMM7_9_S (UIMM7_A32_11R_S + 1) 1980 {7, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm7_9_s, extract_uimm7_9_s}, 1981 1982 /* UIMM3_13_S mask = 0000000000000111. */ 1983 #define UIMM3_13_S (UIMM7_9_S + 1) 1984 {3, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm3_13_s, extract_uimm3_13_s}, 1985 1986 /* Exactly like the above but used for relaxation. */ 1987 #define UIMM3_13R_S (UIMM3_13_S + 1) 1988 {3, 0, -UIMM3_13R_S, ARC_OPERAND_UNSIGNED | ARC_OPERAND_PCREL, 1989 insert_uimm3_13_s, extract_uimm3_13_s}, 1990 1991 /* SIMM11_A32_7_S mask = 0000000111111111. */ 1992 #define SIMM11_A32_7_S (UIMM3_13R_S + 1) 1993 {11, 0, BFD_RELOC_ARC_SDA16_LD2, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED32 1994 | ARC_OPERAND_TRUNCATE, insert_simm11_a32_7_s, extract_simm11_a32_7_s}, 1995 1996 /* UIMM6_13_S mask = 0000000002220111. */ 1997 #define UIMM6_13_S (SIMM11_A32_7_S + 1) 1998 {6, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm6_13_s, extract_uimm6_13_s}, 1999 /* UIMM5_11_S mask = 0000000000011111. */ 2000 #define UIMM5_11_S (UIMM6_13_S + 1) 2001 {5, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_IGNORE, insert_uimm5_11_s, 2002 extract_uimm5_11_s}, 2003 2004 /* SIMM9_A16_8 mask = 00000000111111102000000000000000. */ 2005 #define SIMM9_A16_8 (UIMM5_11_S + 1) 2006 {9, 0, -SIMM9_A16_8, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED16 2007 | ARC_OPERAND_PCREL | ARC_OPERAND_TRUNCATE, insert_simm9_a16_8, 2008 extract_simm9_a16_8}, 2009 2010 /* UIMM6_8 mask = 00000000000000000000111111000000. */ 2011 #define UIMM6_8 (SIMM9_A16_8 + 1) 2012 {6, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm6_8, extract_uimm6_8}, 2013 2014 /* SIMM21_A16_5 mask = 00000111111111102222222222000000. */ 2015 #define SIMM21_A16_5 (UIMM6_8 + 1) 2016 {21, 0, BFD_RELOC_ARC_S21H_PCREL, ARC_OPERAND_SIGNED 2017 | ARC_OPERAND_ALIGNED16 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, 2018 insert_simm21_a16_5, extract_simm21_a16_5}, 2019 2020 /* SIMM25_A16_5 mask = 00000111111111102222222222003333. */ 2021 #define SIMM25_A16_5 (SIMM21_A16_5 + 1) 2022 {25, 0, BFD_RELOC_ARC_S25H_PCREL, ARC_OPERAND_SIGNED 2023 | ARC_OPERAND_ALIGNED16 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, 2024 insert_simm25_a16_5, extract_simm25_a16_5}, 2025 2026 /* SIMM10_A16_7_S mask = 0000000111111111. */ 2027 #define SIMM10_A16_7_S (SIMM25_A16_5 + 1) 2028 {10, 0, -SIMM10_A16_7_S, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED16 2029 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm10_a16_7_s, 2030 extract_simm10_a16_7_s}, 2031 2032 #define SIMM10_A16_7_Sbis (SIMM10_A16_7_S + 1) 2033 {10, 0, -SIMM10_A16_7_Sbis, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED16 2034 | ARC_OPERAND_TRUNCATE, insert_simm10_a16_7_s, extract_simm10_a16_7_s}, 2035 2036 /* SIMM7_A16_10_S mask = 0000000000111111. */ 2037 #define SIMM7_A16_10_S (SIMM10_A16_7_Sbis + 1) 2038 {7, 0, -SIMM7_A16_10_S, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED16 2039 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm7_a16_10_s, 2040 extract_simm7_a16_10_s}, 2041 2042 /* SIMM21_A32_5 mask = 00000111111111002222222222000000. */ 2043 #define SIMM21_A32_5 (SIMM7_A16_10_S + 1) 2044 {21, 0, BFD_RELOC_ARC_S21W_PCREL, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED32 2045 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm21_a32_5, 2046 extract_simm21_a32_5}, 2047 2048 /* SIMM25_A32_5 mask = 00000111111111002222222222003333. */ 2049 #define SIMM25_A32_5 (SIMM21_A32_5 + 1) 2050 {25, 0, BFD_RELOC_ARC_S25W_PCREL, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED32 2051 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm25_a32_5, 2052 extract_simm25_a32_5}, 2053 2054 /* SIMM13_A32_5_S mask = 0000011111111111. */ 2055 #define SIMM13_A32_5_S (SIMM25_A32_5 + 1) 2056 {13, 0, BFD_RELOC_ARC_S13_PCREL, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED32 2057 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm13_a32_5_s, 2058 extract_simm13_a32_5_s}, 2059 2060 /* SIMM8_A16_9_S mask = 0000000001111111. */ 2061 #define SIMM8_A16_9_S (SIMM13_A32_5_S + 1) 2062 {8, 0, -SIMM8_A16_9_S, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED16 2063 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm8_a16_9_s, 2064 extract_simm8_a16_9_s}, 2065 2066 /* UIMM10_6_S_JLIOFF mask = 0000001111111111. */ 2067 #define UIMM10_6_S_JLIOFF (SIMM8_A16_9_S + 1) 2068 {12, 0, BFD_RELOC_ARC_JLI_SECTOFF, ARC_OPERAND_UNSIGNED 2069 | ARC_OPERAND_ALIGNED32 | ARC_OPERAND_TRUNCATE, insert_uimm10_6_s, 2070 extract_uimm10_6_s}, 2071 2072 /* UIMM3_23 mask = 00000000000000000000000111000000. */ 2073 #define UIMM3_23 (UIMM10_6_S_JLIOFF + 1) 2074 {3, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm3_23, extract_uimm3_23}, 2075 2076 /* UIMM10_6_S mask = 0000001111111111. */ 2077 #define UIMM10_6_S (UIMM3_23 + 1) 2078 {10, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm10_6_s, extract_uimm10_6_s}, 2079 2080 /* UIMM6_11_S mask = 0000002200011110. */ 2081 #define UIMM6_11_S (UIMM10_6_S + 1) 2082 {6, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm6_11_s, extract_uimm6_11_s}, 2083 2084 /* SIMM9_8 mask = 00000000111111112000000000000000. */ 2085 #define SIMM9_8 (UIMM6_11_S + 1) 2086 {9, 0, BFD_RELOC_ARC_SDA_LDST, ARC_OPERAND_SIGNED | ARC_OPERAND_IGNORE, 2087 insert_simm9_8, extract_simm9_8}, 2088 2089 /* The same as above but used by relaxation. */ 2090 #define SIMM9_8R (SIMM9_8 + 1) 2091 {9, 0, -SIMM9_8R, ARC_OPERAND_SIGNED | ARC_OPERAND_IGNORE 2092 | ARC_OPERAND_PCREL, insert_simm9_8, extract_simm9_8}, 2093 2094 /* UIMM10_A32_8_S mask = 0000000011111111. */ 2095 #define UIMM10_A32_8_S (SIMM9_8R + 1) 2096 {10, 0, -UIMM10_A32_8_S, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED32 2097 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_uimm10_a32_8_s, 2098 extract_uimm10_a32_8_s}, 2099 2100 /* SIMM9_7_S mask = 0000000111111111. */ 2101 #define SIMM9_7_S (UIMM10_A32_8_S + 1) 2102 {9, 0, BFD_RELOC_ARC_SDA16_LD, ARC_OPERAND_SIGNED, insert_simm9_7_s, 2103 extract_simm9_7_s}, 2104 2105 /* UIMM6_A16_11_S mask = 0000000000011111. */ 2106 #define UIMM6_A16_11_S (SIMM9_7_S + 1) 2107 {6, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED16 2108 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_IGNORE, insert_uimm6_a16_11_s, 2109 extract_uimm6_a16_11_s}, 2110 2111 /* UIMM5_A32_11_S mask = 0000020000011000. */ 2112 #define UIMM5_A32_11_S (UIMM6_A16_11_S + 1) 2113 {5, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED32 2114 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_IGNORE, insert_uimm5_a32_11_s, 2115 extract_uimm5_a32_11_s}, 2116 2117 /* SIMM11_A32_13_S mask = 0000022222200111. */ 2118 #define SIMM11_A32_13_S (UIMM5_A32_11_S + 1) 2119 {11, 0, BFD_RELOC_ARC_SDA16_ST2, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED32 2120 | ARC_OPERAND_TRUNCATE, insert_simm11_a32_13_s, extract_simm11_a32_13_s}, 2121 2122 /* UIMM7_13_S mask = 0000000022220111. */ 2123 #define UIMM7_13_S (SIMM11_A32_13_S + 1) 2124 {7, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm7_13_s, extract_uimm7_13_s}, 2125 2126 /* UIMM6_A16_21 mask = 00000000000000000000011111000000. */ 2127 #define UIMM6_A16_21 (UIMM7_13_S + 1) 2128 {6, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED16 2129 | ARC_OPERAND_TRUNCATE, insert_uimm6_a16_21, extract_uimm6_a16_21}, 2130 2131 /* UIMM7_11_S mask = 0000022200011110. */ 2132 #define UIMM7_11_S (UIMM6_A16_21 + 1) 2133 {7, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm7_11_s, extract_uimm7_11_s}, 2134 2135 /* UIMM7_A16_20 mask = 00000000000000000000111111000000. */ 2136 #define UIMM7_A16_20 (UIMM7_11_S + 1) 2137 {7, 0, -UIMM7_A16_20, ARC_OPERAND_UNSIGNED | ARC_OPERAND_ALIGNED16 2138 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_uimm7_a16_20, 2139 extract_uimm7_a16_20}, 2140 2141 /* SIMM13_A16_20 mask = 00000000000000000000111111222222. */ 2142 #define SIMM13_A16_20 (UIMM7_A16_20 + 1) 2143 {13, 0, -SIMM13_A16_20, ARC_OPERAND_SIGNED | ARC_OPERAND_ALIGNED16 2144 | ARC_OPERAND_TRUNCATE | ARC_OPERAND_PCREL, insert_simm13_a16_20, 2145 extract_simm13_a16_20}, 2146 2147 /* UIMM8_8_S mask = 0000000011111111. */ 2148 #define UIMM8_8_S (SIMM13_A16_20 + 1) 2149 {8, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm8_8_s, extract_uimm8_8_s}, 2150 2151 /* The same as above but used for relaxation. */ 2152 #define UIMM8_8R_S (UIMM8_8_S + 1) 2153 {8, 0, -UIMM8_8R_S, ARC_OPERAND_UNSIGNED | ARC_OPERAND_PCREL, 2154 insert_uimm8_8_s, extract_uimm8_8_s}, 2155 2156 /* W6 mask = 00000000000000000000111111000000. */ 2157 #define W6 (UIMM8_8R_S + 1) 2158 {6, 0, 0, ARC_OPERAND_SIGNED, insert_w6, extract_w6}, 2159 2160 /* UIMM6_5_S mask = 0000011111100000. */ 2161 #define UIMM6_5_S (W6 + 1) 2162 {6, 0, 0, ARC_OPERAND_UNSIGNED, insert_uimm6_5_s, extract_uimm6_5_s}, 2163 2164 /* ARC NPS400 Support: See comment near head of file. */ 2165 #define NPS_R_DST_3B (UIMM6_5_S + 1) 2166 { 3, 24, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2167 insert_nps_3bit_reg_at_24_dst, extract_nps_3bit_reg_at_24_dst }, 2168 2169 #define NPS_R_SRC1_3B (NPS_R_DST_3B + 1) 2170 { 3, 24, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE | ARC_OPERAND_NCHK, 2171 insert_nps_3bit_reg_at_24_dst, extract_nps_3bit_reg_at_24_dst }, 2172 2173 #define NPS_R_SRC2_3B (NPS_R_SRC1_3B + 1) 2174 { 3, 21, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2175 insert_nps_3bit_reg_at_21_src2, extract_nps_3bit_reg_at_21_src2 }, 2176 2177 #define NPS_R_DST (NPS_R_SRC2_3B + 1) 2178 { 6, 21, 0, ARC_OPERAND_IR, NULL, NULL }, 2179 2180 #define NPS_R_SRC1 (NPS_R_DST + 1) 2181 { 6, 21, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE, NULL, NULL }, 2182 2183 #define NPS_BITOP_DST_POS (NPS_R_SRC1 + 1) 2184 { 5, 5, 0, ARC_OPERAND_UNSIGNED, 0, 0 }, 2185 2186 #define NPS_BITOP_SRC_POS (NPS_BITOP_DST_POS + 1) 2187 { 5, 0, 0, ARC_OPERAND_UNSIGNED, 0, 0 }, 2188 2189 #define NPS_BITOP_SIZE (NPS_BITOP_SRC_POS + 1) 2190 { 5, 10, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2191 insert_nps_bitop_size, extract_nps_bitop_size }, 2192 2193 #define NPS_BITOP_DST_POS_SZ (NPS_BITOP_SIZE + 1) 2194 { 5, 0, 0, ARC_OPERAND_UNSIGNED, 2195 insert_nps_dst_pos_and_size, extract_nps_dst_pos_and_size }, 2196 2197 #define NPS_BITOP_SIZE_2B (NPS_BITOP_DST_POS_SZ + 1) 2198 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2199 insert_nps_bitop_size_2b, extract_nps_bitop_size_2b }, 2200 2201 #define NPS_BITOP_UIMM8 (NPS_BITOP_SIZE_2B + 1) 2202 { 8, 0, 0, ARC_OPERAND_UNSIGNED, 2203 insert_nps_bitop_uimm8, extract_nps_bitop_uimm8 }, 2204 2205 #define NPS_UIMM16 (NPS_BITOP_UIMM8 + 1) 2206 { 16, 0, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2207 2208 #define NPS_SIMM16 (NPS_UIMM16 + 1) 2209 { 16, 0, 0, ARC_OPERAND_SIGNED, NULL, NULL }, 2210 2211 #define NPS_RFLT_UIMM6 (NPS_SIMM16 + 1) 2212 { 6, 6, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2213 insert_nps_rflt_uimm6, extract_nps_rflt_uimm6 }, 2214 2215 #define NPS_XLDST_UIMM16 (NPS_RFLT_UIMM6 + 1) 2216 { 16, 0, BFD_RELOC_ARC_NPS_CMEM16, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2217 insert_nps_cmem_uimm16, extract_nps_cmem_uimm16 }, 2218 2219 #define NPS_SRC2_POS (NPS_XLDST_UIMM16 + 1) 2220 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2221 insert_nps_src2_pos, extract_nps_src2_pos }, 2222 2223 #define NPS_SRC1_POS (NPS_SRC2_POS + 1) 2224 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2225 insert_nps_src1_pos, extract_nps_src1_pos }, 2226 2227 #define NPS_ADDB_SIZE (NPS_SRC1_POS + 1) 2228 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2229 insert_nps_addb_size, extract_nps_addb_size }, 2230 2231 #define NPS_ANDB_SIZE (NPS_ADDB_SIZE + 1) 2232 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2233 insert_nps_andb_size, extract_nps_andb_size }, 2234 2235 #define NPS_FXORB_SIZE (NPS_ANDB_SIZE + 1) 2236 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2237 insert_nps_fxorb_size, extract_nps_fxorb_size }, 2238 2239 #define NPS_WXORB_SIZE (NPS_FXORB_SIZE + 1) 2240 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2241 insert_nps_wxorb_size, extract_nps_wxorb_size }, 2242 2243 #define NPS_R_XLDST (NPS_WXORB_SIZE + 1) 2244 { 6, 5, 0, ARC_OPERAND_IR, NULL, NULL }, 2245 2246 #define NPS_DIV_UIMM4 (NPS_R_XLDST + 1) 2247 { 4, 5, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2248 2249 #define NPS_QCMP_SIZE (NPS_DIV_UIMM4 + 1) 2250 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2251 insert_nps_qcmp_size, extract_nps_qcmp_size }, 2252 2253 #define NPS_QCMP_M1 (NPS_QCMP_SIZE + 1) 2254 { 1, 14, 0, ARC_OPERAND_UNSIGNED, NULL, extract_nps_qcmp_m1 }, 2255 2256 #define NPS_QCMP_M2 (NPS_QCMP_M1 + 1) 2257 { 1, 15, 0, ARC_OPERAND_UNSIGNED, NULL, extract_nps_qcmp_m2 }, 2258 2259 #define NPS_QCMP_M3 (NPS_QCMP_M2 + 1) 2260 { 4, 5, 0, ARC_OPERAND_UNSIGNED, NULL, extract_nps_qcmp_m3 }, 2261 2262 #define NPS_CALC_ENTRY_SIZE (NPS_QCMP_M3 + 1) 2263 { 0, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2264 insert_nps_calc_entry_size, extract_nps_calc_entry_size }, 2265 2266 #define NPS_R_DST_3B_SHORT (NPS_CALC_ENTRY_SIZE + 1) 2267 { 3, 8, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2268 insert_nps_3bit_reg_at_8_dst, extract_nps_3bit_reg_at_8_dst }, 2269 2270 #define NPS_R_SRC1_3B_SHORT (NPS_R_DST_3B_SHORT + 1) 2271 { 3, 8, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE | ARC_OPERAND_NCHK, 2272 insert_nps_3bit_reg_at_8_dst, extract_nps_3bit_reg_at_8_dst }, 2273 2274 #define NPS_R_SRC2_3B_SHORT (NPS_R_SRC1_3B_SHORT + 1) 2275 { 3, 5, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2276 insert_nps_3bit_reg_at_5_src2, extract_nps_3bit_reg_at_5_src2 }, 2277 2278 #define NPS_BITOP_SIZE2 (NPS_R_SRC2_3B_SHORT + 1) 2279 { 5, 25, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2280 insert_nps_bitop2_size, extract_nps_bitop2_size }, 2281 2282 #define NPS_BITOP_SIZE1 (NPS_BITOP_SIZE2 + 1) 2283 { 5, 20, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2284 insert_nps_bitop1_size, extract_nps_bitop1_size }, 2285 2286 #define NPS_BITOP_DST_POS3_POS4 (NPS_BITOP_SIZE1 + 1) 2287 { 5, 0, 0, ARC_OPERAND_UNSIGNED, 2288 insert_nps_bitop_dst_pos3_pos4, extract_nps_bitop_dst_pos3_pos4 }, 2289 2290 #define NPS_BITOP_DST_POS4 (NPS_BITOP_DST_POS3_POS4 + 1) 2291 { 5, 42, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2292 2293 #define NPS_BITOP_DST_POS3 (NPS_BITOP_DST_POS4 + 1) 2294 { 5, 37, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2295 2296 #define NPS_BITOP_DST_POS2 (NPS_BITOP_DST_POS3 + 1) 2297 { 5, 15, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2298 2299 #define NPS_BITOP_DST_POS1 (NPS_BITOP_DST_POS2 + 1) 2300 { 5, 10, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2301 2302 #define NPS_BITOP_SRC_POS4 (NPS_BITOP_DST_POS1 + 1) 2303 { 5, 32, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2304 2305 #define NPS_BITOP_SRC_POS3 (NPS_BITOP_SRC_POS4 + 1) 2306 { 5, 20, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2307 2308 #define NPS_BITOP_SRC_POS2 (NPS_BITOP_SRC_POS3 + 1) 2309 { 5, 5, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2310 2311 #define NPS_BITOP_SRC_POS1 (NPS_BITOP_SRC_POS2 + 1) 2312 { 5, 0, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2313 2314 #define NPS_BITOP_MOD4 (NPS_BITOP_SRC_POS1 + 1) 2315 { 2, 0, 0, ARC_OPERAND_UNSIGNED, 2316 insert_nps_bitop_mod4, extract_nps_bitop_mod4 }, 2317 2318 #define NPS_BITOP_MOD3 (NPS_BITOP_MOD4 + 1) 2319 { 2, 29, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2320 2321 #define NPS_BITOP_MOD2 (NPS_BITOP_MOD3 + 1) 2322 { 2, 27, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2323 2324 #define NPS_BITOP_MOD1 (NPS_BITOP_MOD2 + 1) 2325 { 2, 25, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2326 2327 #define NPS_BITOP_INS_EXT (NPS_BITOP_MOD1 + 1) 2328 { 5, 20, 0, ARC_OPERAND_UNSIGNED, 2329 insert_nps_bitop_ins_ext, extract_nps_bitop_ins_ext }, 2330 2331 #define NPS_FIELD_START_POS (NPS_BITOP_INS_EXT + 1) 2332 { 3, 3, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2333 2334 #define NPS_FIELD_SIZE (NPS_FIELD_START_POS + 1) 2335 { 3, 6, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2336 insert_nps_field_size, extract_nps_field_size }, 2337 2338 #define NPS_SHIFT_FACTOR (NPS_FIELD_SIZE + 1) 2339 { 3, 9, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2340 insert_nps_shift_factor, extract_nps_shift_factor }, 2341 2342 #define NPS_BITS_TO_SCRAMBLE (NPS_SHIFT_FACTOR + 1) 2343 { 3, 12, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2344 insert_nps_bits_to_scramble, extract_nps_bits_to_scramble }, 2345 2346 #define NPS_SRC2_POS_5B (NPS_BITS_TO_SCRAMBLE + 1) 2347 { 5, 5, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2348 2349 #define NPS_BDLEN_MAX_LEN (NPS_SRC2_POS_5B + 1) 2350 { 8, 5, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2351 insert_nps_bdlen_max_len, extract_nps_bdlen_max_len }, 2352 2353 #define NPS_MIN_HOFS (NPS_BDLEN_MAX_LEN + 1) 2354 { 4, 6, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2355 insert_nps_min_hofs, extract_nps_min_hofs }, 2356 2357 #define NPS_PSBC (NPS_MIN_HOFS + 1) 2358 { 1, 11, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2359 2360 #define NPS_DPI_DST (NPS_PSBC + 1) 2361 { 5, 11, 0, ARC_OPERAND_IR, NULL, NULL }, 2362 2363 /* NPS_DPI_SRC1_3B is similar to NPS_R_SRC1_3B 2364 but doesn't duplicate an operand. */ 2365 #define NPS_DPI_SRC1_3B (NPS_DPI_DST + 1) 2366 { 3, 24, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2367 insert_nps_3bit_reg_at_24_dst, extract_nps_3bit_reg_at_24_dst }, 2368 2369 #define NPS_HASH_WIDTH (NPS_DPI_SRC1_3B + 1) 2370 { 5, 6, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2371 insert_nps_hash_width, extract_nps_hash_width }, 2372 2373 #define NPS_HASH_PERM (NPS_HASH_WIDTH + 1) 2374 { 3, 2, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2375 2376 #define NPS_HASH_NONLINEAR (NPS_HASH_PERM + 1) 2377 { 1, 5, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2378 2379 #define NPS_HASH_BASEMAT (NPS_HASH_NONLINEAR + 1) 2380 { 2, 0, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2381 2382 #define NPS_HASH_LEN (NPS_HASH_BASEMAT + 1) 2383 { 3, 2, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2384 insert_nps_hash_len, extract_nps_hash_len }, 2385 2386 #define NPS_HASH_OFS (NPS_HASH_LEN + 1) 2387 { 2, 0, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2388 2389 #define NPS_HASH_BASEMAT2 (NPS_HASH_OFS + 1) 2390 { 1, 5, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2391 2392 #define NPS_E4BY_INDEX0 (NPS_HASH_BASEMAT2 + 1) 2393 { 3, 8, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2394 2395 #define NPS_E4BY_INDEX1 (NPS_E4BY_INDEX0 + 1) 2396 { 3, 5, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2397 2398 #define NPS_E4BY_INDEX2 (NPS_E4BY_INDEX1 + 1) 2399 { 3, 2, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2400 2401 #define NPS_E4BY_INDEX3 (NPS_E4BY_INDEX2 + 1) 2402 { 2, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2403 insert_nps_index3, extract_nps_index3 }, 2404 2405 #define COLON (NPS_E4BY_INDEX3 + 1) 2406 { 0, 0, 0, ARC_OPERAND_COLON | ARC_OPERAND_FAKE, NULL, NULL }, 2407 2408 #define NPS_BD (COLON + 1) 2409 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2410 insert_nps_bd, extract_nps_bd }, 2411 2412 #define NPS_JID (NPS_BD + 1) 2413 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2414 insert_nps_jid, extract_nps_jid }, 2415 2416 #define NPS_LBD (NPS_JID + 1) 2417 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2418 insert_nps_lbd, extract_nps_lbd }, 2419 2420 #define NPS_MBD (NPS_LBD + 1) 2421 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2422 insert_nps_mbd, extract_nps_mbd }, 2423 2424 #define NPS_SD (NPS_MBD + 1) 2425 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2426 insert_nps_sd, extract_nps_sd }, 2427 2428 #define NPS_SM (NPS_SD + 1) 2429 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2430 insert_nps_sm, extract_nps_sm }, 2431 2432 #define NPS_XA (NPS_SM + 1) 2433 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2434 insert_nps_xa, extract_nps_xa }, 2435 2436 #define NPS_XD (NPS_XA + 1) 2437 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2438 insert_nps_xd, extract_nps_xd }, 2439 2440 #define NPS_CD (NPS_XD + 1) 2441 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2442 insert_nps_cd, extract_nps_cd }, 2443 2444 #define NPS_CBD (NPS_CD + 1) 2445 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2446 insert_nps_cbd, extract_nps_cbd }, 2447 2448 #define NPS_CJID (NPS_CBD + 1) 2449 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2450 insert_nps_cjid, extract_nps_cjid }, 2451 2452 #define NPS_CLBD (NPS_CJID + 1) 2453 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2454 insert_nps_clbd, extract_nps_clbd }, 2455 2456 #define NPS_CM (NPS_CLBD + 1) 2457 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2458 insert_nps_cm, extract_nps_cm }, 2459 2460 #define NPS_CSD (NPS_CM + 1) 2461 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2462 insert_nps_csd, extract_nps_csd }, 2463 2464 #define NPS_CXA (NPS_CSD + 1) 2465 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2466 insert_nps_cxa, extract_nps_cxa }, 2467 2468 #define NPS_CXD (NPS_CXA + 1) 2469 { 0, 0, 0, ARC_OPERAND_ADDRTYPE | ARC_OPERAND_NCHK, 2470 insert_nps_cxd, extract_nps_cxd }, 2471 2472 #define NPS_BD_TYPE (NPS_CXD + 1) 2473 { 1, 10, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2474 2475 #define NPS_BMU_NUM (NPS_BD_TYPE + 1) 2476 { 3, 0, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2477 insert_nps_bd_num_buff, extract_nps_bd_num_buff }, 2478 2479 #define NPS_PMU_NXT_DST (NPS_BMU_NUM + 1) 2480 { 4, 6, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2481 2482 #define NPS_WHASH_SIZE (NPS_PMU_NXT_DST + 1) 2483 { 6, 6, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2484 insert_nps_size_16bit, extract_nps_size_16bit }, 2485 2486 #define NPS_PMU_NUM_JOB (NPS_WHASH_SIZE + 1) 2487 { 2, 6, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2488 insert_nps_pmu_num_job, extract_nps_pmu_num_job }, 2489 2490 #define NPS_DMA_IMM_ENTRY (NPS_PMU_NUM_JOB + 1) 2491 { 3, 2, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2492 insert_nps_imm_entry, extract_nps_imm_entry }, 2493 2494 #define NPS_DMA_IMM_OFFSET (NPS_DMA_IMM_ENTRY + 1) 2495 { 4, 10, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2496 insert_nps_imm_offset, extract_nps_imm_offset }, 2497 2498 #define NPS_MISC_IMM_SIZE (NPS_DMA_IMM_OFFSET + 1) 2499 { 7, 0, 0, ARC_OPERAND_UNSIGNED , NULL, NULL }, 2500 2501 #define NPS_MISC_IMM_OFFSET (NPS_MISC_IMM_SIZE + 1) 2502 { 5, 8, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2503 insert_nps_misc_imm_offset, extract_nps_misc_imm_offset }, 2504 2505 #define NPS_R_DST_3B_48 (NPS_MISC_IMM_OFFSET + 1) 2506 { 3, 40, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2507 insert_nps_3bit_reg_at_40_dst, extract_nps_3bit_reg_at_40_dst }, 2508 2509 #define NPS_R_SRC1_3B_48 (NPS_R_DST_3B_48 + 1) 2510 { 3, 40, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE | ARC_OPERAND_NCHK, 2511 insert_nps_3bit_reg_at_40_dst, extract_nps_3bit_reg_at_40_dst }, 2512 2513 #define NPS_R_SRC2_3B_48 (NPS_R_SRC1_3B_48 + 1) 2514 { 3, 37, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2515 insert_nps_3bit_reg_at_37_src2, extract_nps_3bit_reg_at_37_src2 }, 2516 2517 #define NPS_R_DST_3B_64 (NPS_R_SRC2_3B_48 + 1) 2518 { 3, 56, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2519 insert_nps_3bit_reg_at_56_dst, extract_nps_3bit_reg_at_56_dst }, 2520 2521 #define NPS_R_SRC1_3B_64 (NPS_R_DST_3B_64 + 1) 2522 { 3, 56, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE | ARC_OPERAND_NCHK, 2523 insert_nps_3bit_reg_at_56_dst, extract_nps_3bit_reg_at_56_dst }, 2524 2525 #define NPS_R_SRC2_3B_64 (NPS_R_SRC1_3B_64 + 1) 2526 { 3, 53, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2527 insert_nps_3bit_reg_at_53_src2, extract_nps_3bit_reg_at_53_src2 }, 2528 2529 #define NPS_RA_64 (NPS_R_SRC2_3B_64 + 1) 2530 { 6, 53, 0, ARC_OPERAND_IR, NULL, NULL }, 2531 2532 #define NPS_RB_64 (NPS_RA_64 + 1) 2533 { 5, 48, 0, ARC_OPERAND_IR, NULL, NULL }, 2534 2535 #define NPS_RBdup_64 (NPS_RB_64 + 1) 2536 { 5, 43, 0, ARC_OPERAND_IR | ARC_OPERAND_DUPLICATE, NULL, NULL }, 2537 2538 #define NPS_RBdouble_64 (NPS_RBdup_64 + 1) 2539 { 10, 43, 0, ARC_OPERAND_IR | ARC_OPERAND_NCHK, 2540 insert_nps_rbdouble_64, extract_nps_rbdouble_64 }, 2541 2542 #define NPS_RC_64 (NPS_RBdouble_64 + 1) 2543 { 5, 43, 0, ARC_OPERAND_IR, NULL, NULL }, 2544 2545 #define NPS_UIMM16_0_64 (NPS_RC_64 + 1) 2546 { 16, 0, 0, ARC_OPERAND_UNSIGNED, NULL, NULL }, 2547 2548 #define NPS_PROTO_SIZE (NPS_UIMM16_0_64 + 1) 2549 { 6, 16, 0, ARC_OPERAND_UNSIGNED | ARC_OPERAND_NCHK, 2550 insert_nps_proto_size, extract_nps_proto_size } 2551 }; 2552 const unsigned arc_num_operands = ARRAY_SIZE (arc_operands); 2553 2554 const unsigned arc_Toperand = FKT_T; 2555 const unsigned arc_NToperand = FKT_NT; 2556 2557 const unsigned char arg_none[] = { 0 }; 2558 const unsigned char arg_32bit_rarbrc[] = { RA, RB, RC }; 2559 const unsigned char arg_32bit_zarbrc[] = { ZA, RB, RC }; 2560 const unsigned char arg_32bit_rbrbrc[] = { RB, RBdup, RC }; 2561 const unsigned char arg_32bit_rarbu6[] = { RA, RB, UIMM6_20 }; 2562 const unsigned char arg_32bit_zarbu6[] = { ZA, RB, UIMM6_20 }; 2563 const unsigned char arg_32bit_rbrbu6[] = { RB, RBdup, UIMM6_20 }; 2564 const unsigned char arg_32bit_rbrbs12[] = { RB, RBdup, SIMM12_20 }; 2565 const unsigned char arg_32bit_ralimmrc[] = { RA, LIMM, RC }; 2566 const unsigned char arg_32bit_rarblimm[] = { RA, RB, LIMM }; 2567 const unsigned char arg_32bit_zalimmrc[] = { ZA, LIMM, RC }; 2568 const unsigned char arg_32bit_zarblimm[] = { ZA, RB, LIMM }; 2569 2570 const unsigned char arg_32bit_rbrblimm[] = { RB, RBdup, LIMM }; 2571 const unsigned char arg_32bit_ralimmu6[] = { RA, LIMM, UIMM6_20 }; 2572 const unsigned char arg_32bit_zalimmu6[] = { ZA, LIMM, UIMM6_20 }; 2573 2574 const unsigned char arg_32bit_zalimms12[] = { ZA, LIMM, SIMM12_20 }; 2575 const unsigned char arg_32bit_ralimmlimm[] = { RA, LIMM, LIMMdup }; 2576 const unsigned char arg_32bit_zalimmlimm[] = { ZA, LIMM, LIMMdup }; 2577 2578 const unsigned char arg_32bit_rbrc[] = { RB, RC }; 2579 const unsigned char arg_32bit_zarc[] = { ZA, RC }; 2580 const unsigned char arg_32bit_rbu6[] = { RB, UIMM6_20 }; 2581 const unsigned char arg_32bit_zau6[] = { ZA, UIMM6_20 }; 2582 const unsigned char arg_32bit_rblimm[] = { RB, LIMM }; 2583 const unsigned char arg_32bit_zalimm[] = { ZA, LIMM }; 2584 2585 const unsigned char arg_32bit_limmrc[] = { LIMM, RC }; 2586 const unsigned char arg_32bit_limmu6[] = { LIMM, UIMM6_20 }; 2587 const unsigned char arg_32bit_limms12[] = { LIMM, SIMM12_20 }; 2588 const unsigned char arg_32bit_limmlimm[] = { LIMM, LIMMdup }; 2589 2590 const unsigned char arg_32bit_rc[] = { RC }; 2591 const unsigned char arg_32bit_u6[] = { UIMM6_20 }; 2592 const unsigned char arg_32bit_limm[] = { LIMM }; 2593 2594 /* The opcode table. 2595 2596 The format of the opcode table is: 2597 2598 NAME OPCODE MASK CPU CLASS SUBCLASS { OPERANDS } { FLAGS }. 2599 2600 The table is organised such that, where possible, all instructions with 2601 the same mnemonic are together in a block. When the assembler searches 2602 for a suitable instruction the entries are checked in table order, so 2603 more specific, or specialised cases should appear earlier in the table. 2604 2605 As an example, consider two instructions 'add a,b,u6' and 'add 2606 a,b,limm'. The first takes a 6-bit immediate that is encoded within the 2607 32-bit instruction, while the second takes a 32-bit immediate that is 2608 encoded in a follow-on 32-bit, making the total instruction length 2609 64-bits. In this case the u6 variant must appear first in the table, as 2610 all u6 immediates could also be encoded using the 'limm' extension, 2611 however, we want to use the shorter instruction wherever possible. 2612 2613 It is possible though to split instructions with the same mnemonic into 2614 multiple groups. However, the instructions are still checked in table 2615 order, even across groups. The only time that instructions with the 2616 same mnemonic should be split into different groups is when different 2617 variants of the instruction appear in different architectures, in which 2618 case, grouping all instructions from a particular architecture together 2619 might be preferable to merging the instruction into the main instruction 2620 table. 2621 2622 An example of this split instruction groups can be found with the 'sync' 2623 instruction. The core arc architecture provides a 'sync' instruction, 2624 while the nps instruction set extension provides 'sync.rd' and 2625 'sync.wr'. The rd/wr flags are instruction flags, not part of the 2626 mnemonic, so we end up with two groups for the sync instruction, the 2627 first within the core arc instruction table, and the second within the 2628 nps extension instructions. */ 2629 const struct arc_opcode arc_opcodes[] = 2630 { 2631 #include "arc-tbl.h" 2632 #include "arc-nps400-tbl.h" 2633 #include "arc-ext-tbl.h" 2634 2635 { NULL, 0, 0, 0, 0, 0, { 0 }, { 0 } } 2636 }; 2637 2638 /* List with special cases instructions and the applicable flags. */ 2639 const struct arc_flag_special arc_flag_special_cases[] = 2640 { 2641 { "b", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2642 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2643 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2644 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NJ, F_NM, 2645 F_NO_T, F_NULL } }, 2646 { "bl", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2647 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2648 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2649 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NULL } }, 2650 { "br", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2651 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2652 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2653 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NULL } }, 2654 { "j", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2655 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2656 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2657 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NULL } }, 2658 { "jl", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2659 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2660 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2661 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NULL } }, 2662 { "lp", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2663 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2664 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2665 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NULL } }, 2666 { "set", { F_ALWAYS, F_RA, F_EQUAL, F_ZERO, F_NOTEQUAL, F_NOTZERO, F_POZITIVE, 2667 F_PL, F_NEGATIVE, F_MINUS, F_CARRY, F_CARRYSET, F_LOWER, F_CARRYCLR, 2668 F_NOTCARRY, F_HIGHER, F_OVERFLOWSET, F_OVERFLOW, F_NOTOVERFLOW, 2669 F_OVERFLOWCLR, F_GT, F_GE, F_LT, F_LE, F_HI, F_LS, F_PNZ, F_NULL } }, 2670 { "ld", { F_SIZEB17, F_SIZEW17, F_H17, F_NULL } }, 2671 { "st", { F_SIZEB1, F_SIZEW1, F_H1, F_NULL } } 2672 }; 2673 2674 const unsigned arc_num_flag_special = ARRAY_SIZE (arc_flag_special_cases); 2675 2676 /* Relocations. */ 2677 const struct arc_reloc_equiv_tab arc_reloc_equiv[] = 2678 { 2679 { "sda", "ld", { F_ASFAKE, F_H1, F_NULL }, 2680 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST1 }, 2681 { "sda", "st", { F_ASFAKE, F_H1, F_NULL }, 2682 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST1 }, 2683 { "sda", "ld", { F_ASFAKE, F_SIZEW7, F_NULL }, 2684 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST1 }, 2685 { "sda", "st", { F_ASFAKE, F_SIZEW7, F_NULL }, 2686 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST1 }, 2687 2688 /* Next two entries will cover the undefined behavior ldb/stb with 2689 address scaling. */ 2690 { "sda", "ld", { F_ASFAKE, F_SIZEB7, F_NULL }, 2691 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST }, 2692 { "sda", "st", { F_ASFAKE, F_SIZEB7, F_NULL }, 2693 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST}, 2694 2695 { "sda", "ld", { F_ASFAKE, F_NULL }, 2696 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST2 }, 2697 { "sda", "st", { F_ASFAKE, F_NULL }, 2698 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST2}, 2699 { "sda", "ldd", { F_ASFAKE, F_NULL }, 2700 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST2 }, 2701 { "sda", "std", { F_ASFAKE, F_NULL }, 2702 BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST2}, 2703 2704 /* Short instructions. */ 2705 { "sda", 0, { F_NULL }, BFD_RELOC_ARC_SDA16_LD, BFD_RELOC_ARC_SDA16_LD }, 2706 { "sda", 0, { F_NULL }, -SIMM10_A16_7_Sbis, BFD_RELOC_ARC_SDA16_LD1 }, 2707 { "sda", 0, { F_NULL }, BFD_RELOC_ARC_SDA16_LD2, BFD_RELOC_ARC_SDA16_LD2 }, 2708 { "sda", 0, { F_NULL }, BFD_RELOC_ARC_SDA16_ST2, BFD_RELOC_ARC_SDA16_ST2 }, 2709 2710 { "sda", 0, { F_NULL }, BFD_RELOC_ARC_32_ME, BFD_RELOC_ARC_SDA32_ME }, 2711 { "sda", 0, { F_NULL }, BFD_RELOC_ARC_SDA_LDST, BFD_RELOC_ARC_SDA_LDST }, 2712 2713 { "plt", 0, { F_NULL }, BFD_RELOC_ARC_S25H_PCREL, 2714 BFD_RELOC_ARC_S25H_PCREL_PLT }, 2715 { "plt", 0, { F_NULL }, BFD_RELOC_ARC_S21H_PCREL, 2716 BFD_RELOC_ARC_S21H_PCREL_PLT }, 2717 { "plt", 0, { F_NULL }, BFD_RELOC_ARC_S25W_PCREL, 2718 BFD_RELOC_ARC_S25W_PCREL_PLT }, 2719 { "plt", 0, { F_NULL }, BFD_RELOC_ARC_S21W_PCREL, 2720 BFD_RELOC_ARC_S21W_PCREL_PLT }, 2721 2722 { "plt", 0, { F_NULL }, BFD_RELOC_ARC_32_ME, BFD_RELOC_ARC_PLT32 } 2723 }; 2724 2725 const unsigned arc_num_equiv_tab = ARRAY_SIZE (arc_reloc_equiv); 2726 2727 const struct arc_pseudo_insn arc_pseudo_insns[] = 2728 { 2729 { "push", "st", ".aw", 5, { { RC, 0, 0, 0 }, { BRAKET, 1, 0, 1 }, 2730 { RB, 1, 28, 2 }, { SIMM9_8, 1, -4, 3 }, 2731 { BRAKETdup, 1, 0, 4} } }, 2732 { "pop", "ld", ".ab", 5, { { RA, 0, 0, 0 }, { BRAKET, 1, 0, 1 }, 2733 { RB, 1, 28, 2 }, { SIMM9_8, 1, 4, 3 }, 2734 { BRAKETdup, 1, 0, 4} } }, 2735 2736 { "brgt", "brlt", NULL, 3, { { RB, 0, 0, 1 }, { RC, 0, 0, 0 }, 2737 { SIMM9_A16_8, 0, 0, 2 } } }, 2738 { "brgt", "brge", NULL, 3, { { RB, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2739 { SIMM9_A16_8, 0, 0, 2 } } }, 2740 { "brgt", "brlt", NULL, 3, { { RB, 0, 0, 1 }, { LIMM, 0, 0, 0 }, 2741 { SIMM9_A16_8, 0, 0, 2 } } }, 2742 { "brgt", "brlt", NULL, 3, { { LIMM, 0, 0, 1 }, { RC, 0, 0, 0 }, 2743 { SIMM9_A16_8, 0, 0, 2 } } }, 2744 { "brgt", "brge", NULL, 3, { { LIMM, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2745 { SIMM9_A16_8, 0, 0, 2 } } }, 2746 2747 { "brhi", "brlo", NULL, 3, { { RB, 0, 0, 1 }, { RC, 0, 0, 0 }, 2748 { SIMM9_A16_8, 0, 0, 2 } } }, 2749 { "brhi", "brhs", NULL, 3, { { RB, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2750 { SIMM9_A16_8, 0, 0, 2 } } }, 2751 { "brhi", "brlo", NULL, 3, { { RB, 0, 0, 1 }, { LIMM, 0, 0, 0 }, 2752 { SIMM9_A16_8, 0, 0, 2 } } }, 2753 { "brhi", "brlo", NULL, 3, { { LIMM, 0, 0, 1 }, { RC, 0, 0, 0 }, 2754 { SIMM9_A16_8, 0, 0, 2 } } }, 2755 { "brhi", "brhs", NULL, 3, { { LIMM, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2756 { SIMM9_A16_8, 0, 0, 2 } } }, 2757 2758 { "brle", "brge", NULL, 3, { { RB, 0, 0, 1 }, { RC, 0, 0, 0 }, 2759 { SIMM9_A16_8, 0, 0, 2 } } }, 2760 { "brle", "brlt", NULL, 3, { { RB, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2761 { SIMM9_A16_8, 0, 0, 2 } } }, 2762 { "brle", "brge", NULL, 3, { { RB, 0, 0, 1 }, { LIMM, 0, 0, 0 }, 2763 { SIMM9_A16_8, 0, 0, 2 } } }, 2764 { "brle", "brge", NULL, 3, { { LIMM, 0, 0, 1 }, { RC, 0, 0, 0 }, 2765 { SIMM9_A16_8, 0, 0, 2 } } }, 2766 { "brle", "brlt", NULL, 3, { { LIMM, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2767 { SIMM9_A16_8, 0, 0, 2 } } }, 2768 2769 { "brls", "brhs", NULL, 3, { { RB, 0, 0, 1 }, { RC, 0, 0, 0 }, 2770 { SIMM9_A16_8, 0, 0, 2 } } }, 2771 { "brls", "brlo", NULL, 3, { { RB, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2772 { SIMM9_A16_8, 0, 0, 2 } } }, 2773 { "brls", "brhs", NULL, 3, { { RB, 0, 0, 1 }, { LIMM, 0, 0, 0 }, 2774 { SIMM9_A16_8, 0, 0, 2 } } }, 2775 { "brls", "brhs", NULL, 3, { { LIMM, 0, 0, 1 }, { RC, 0, 0, 0 }, 2776 { SIMM9_A16_8, 0, 0, 2 } } }, 2777 { "brls", "brlo", NULL, 3, { { LIMM, 0, 0, 0 }, { UIMM6_8, 0, 1, 1 }, 2778 { SIMM9_A16_8, 0, 0, 2 } } }, 2779 }; 2780 2781 const unsigned arc_num_pseudo_insn = 2782 sizeof (arc_pseudo_insns) / sizeof (*arc_pseudo_insns); 2783 2784 const struct arc_aux_reg arc_aux_regs[] = 2785 { 2786 #undef DEF 2787 #define DEF(ADDR, CPU, SUBCLASS, NAME) \ 2788 { ADDR, CPU, SUBCLASS, #NAME, sizeof (#NAME)-1 }, 2789 2790 #include "arc-regs.h" 2791 2792 #undef DEF 2793 }; 2794 2795 const unsigned arc_num_aux_regs = ARRAY_SIZE (arc_aux_regs); 2796 2797 /* NOTE: The order of this array MUST be consistent with 'enum 2798 arc_rlx_types' located in tc-arc.h! */ 2799 const struct arc_opcode arc_relax_opcodes[] = 2800 { 2801 { NULL, 0x0, 0x0, 0x0, ARITH, NONE, { UNUSED }, { 0 } }, 2802 2803 /* bl_s s13 11111sssssssssss. */ 2804 { "bl_s", 0x0000F800, 0x0000F800, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2805 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, BRANCH, NONE, 2806 { SIMM13_A32_5_S }, { 0 }}, 2807 2808 /* bl<.d> s25 00001sssssssss10SSSSSSSSSSNRtttt. */ 2809 { "bl", 0x08020000, 0xF8030000, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2810 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, BRANCH, NONE, 2811 { SIMM25_A32_5 }, { C_D }}, 2812 2813 /* b_s s10 1111000sssssssss. */ 2814 { "b_s", 0x0000F000, 0x0000FE00, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2815 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, BRANCH, NONE, 2816 { SIMM10_A16_7_S }, { 0 }}, 2817 2818 /* b<.d> s25 00000ssssssssss1SSSSSSSSSSNRtttt. */ 2819 { "b", 0x00010000, 0xF8010000, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2820 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, BRANCH, NONE, 2821 { SIMM25_A16_5 }, { C_D }}, 2822 2823 /* add_s c,b,u3 01101bbbccc00uuu. */ 2824 { "add_s", 0x00006800, 0x0000F818, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2825 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2826 { RC_S, RB_S, UIMM3_13R_S }, { 0 }}, 2827 2828 /* add<.f> a,b,u6 00100bbb01000000FBBBuuuuuuAAAAAA. */ 2829 { "add", 0x20400000, 0xF8FF0000, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2830 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2831 { RA, RB, UIMM6_20R }, { C_F }}, 2832 2833 /* add<.f> a,b,limm 00100bbb00000000FBBB111110AAAAAA. */ 2834 { "add", 0x20000F80, 0xF8FF0FC0, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2835 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2836 { RA, RB, LIMM }, { C_F }}, 2837 2838 /* ld_s c,b,u7 10000bbbcccuuuuu. */ 2839 { "ld_s", 0x00008000, 0x0000F800, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2840 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2841 { RC_S, BRAKET, RB_S, UIMM7_A32_11R_S, BRAKETdup }, { 0 }}, 2842 2843 /* ld<.di><.aa><.x><zz> a,b,s9 2844 00010bbbssssssssSBBBDaaZZXAAAAAA. */ 2845 { "ld", 0x10000000, 0xF8000000, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2846 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2847 { RA, BRAKET, RB, SIMM9_8R, BRAKETdup }, 2848 { C_ZZ23, C_DI20, C_AA21, C_X25 }}, 2849 2850 /* ld<.di><.aa><.x><zz> a,b,limm 00100bbbaa110ZZXDBBB111110AAAAAA. */ 2851 { "ld", 0x20300F80, 0xF8380FC0, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2852 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2853 { RA, BRAKET, RB, LIMM, BRAKETdup }, 2854 { C_ZZ13, C_DI16, C_AA8, C_X15 }}, 2855 2856 /* mov_s b,u8 11011bbbuuuuuuuu. */ 2857 { "mov_s", 0x0000D800, 0x0000F800, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2858 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2859 { RB_S, UIMM8_8R_S }, { 0 }}, 2860 2861 /* mov<.f> b,s12 00100bbb10001010FBBBssssssSSSSSS. */ 2862 { "mov", 0x208A0000, 0xF8FF0000, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2863 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2864 { RB, SIMM12_20R }, { C_F }}, 2865 2866 /* mov<.f> b,limm 00100bbb00001010FBBB111110RRRRRR. */ 2867 { "mov", 0x200A0F80, 0xF8FF0FC0, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2868 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2869 { RB, LIMM }, { C_F }}, 2870 2871 /* sub_s c,b,u3 01101bbbccc01uuu. */ 2872 { "sub_s", 0x00006808, 0x0000F818, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2873 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2874 { RC_S, RB_S, UIMM3_13R_S }, { 0 }}, 2875 2876 /* sub<.f> a,b,u6 00100bbb01000010FBBBuuuuuuAAAAAA. */ 2877 { "sub", 0x20420000, 0xF8FF0000, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2878 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2879 { RA, RB, UIMM6_20R }, { C_F }}, 2880 2881 /* sub<.f> a,b,limm 00100bbb00000010FBBB111110AAAAAA. */ 2882 { "sub", 0x20020F80, 0xF8FF0FC0, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2883 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2884 { RA, RB, LIMM }, { C_F }}, 2885 2886 /* mpy<.f> a,b,u6 00100bbb01011010FBBBuuuuuuAAAAAA. */ 2887 { "mpy", 0x205A0000, 0xF8FF0000, ARC_OPCODE_ARC700 | ARC_OPCODE_ARCv2EM 2888 | ARC_OPCODE_ARCv2HS, ARITH, MPY6E, { RA, RB, UIMM6_20R }, { C_F }}, 2889 2890 /* mpy<.f> a,b,limm 00100bbb00011010FBBB111110AAAAAA. */ 2891 { "mpy", 0x201A0F80, 0xF8FF0FC0, ARC_OPCODE_ARC700 | ARC_OPCODE_ARCv2EM 2892 | ARC_OPCODE_ARCv2HS, ARITH, MPY6E, { RA, RB, LIMM }, { C_F }}, 2893 2894 /* mov<.f><.cc> b,u6 00100bbb11001010FBBBuuuuuu1QQQQQ. */ 2895 { "mov", 0x20CA0020, 0xF8FF0020, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2896 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2897 { RB, UIMM6_20R }, { C_F, C_CC }}, 2898 2899 /* mov<.f><.cc> b,limm 00100bbb11001010FBBB1111100QQQQQ. */ 2900 { "mov", 0x20CA0F80, 0xF8FF0FE0, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2901 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, MEMORY, NONE, 2902 { RB, LIMM }, { C_F, C_CC }}, 2903 2904 /* add<.f><.cc> b,b,u6 00100bbb11000000FBBBuuuuuu1QQQQQ. */ 2905 { "add", 0x20C00020, 0xF8FF0020, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2906 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2907 { RB, RBdup, UIMM6_20R }, { C_F, C_CC }}, 2908 2909 /* add<.f><.cc> b,b,limm 00100bbb11000000FBBB1111100QQQQQ. */ 2910 { "add", 0x20C00F80, 0xF8FF0FE0, ARC_OPCODE_ARC600 | ARC_OPCODE_ARC700 2911 | ARC_OPCODE_ARCv2EM | ARC_OPCODE_ARCv2HS, ARITH, NONE, 2912 { RB, RBdup, LIMM }, { C_F, C_CC }} 2913 }; 2914 2915 const unsigned arc_num_relax_opcodes = ARRAY_SIZE (arc_relax_opcodes); 2916 2917 /* Return length of an opcode in bytes. */ 2918 2919 int 2920 arc_opcode_len (const struct arc_opcode *opcode) 2921 { 2922 if (opcode->mask < 0x10000ull) 2923 return 2; 2924 2925 if (opcode->mask < 0x100000000ull) 2926 return 4; 2927 2928 if (opcode->mask < 0x1000000000000ull) 2929 return 6; 2930 2931 return 8; 2932 } 2933