opcodes/arc-fxi.h

   1 /* Insert/extract functions for the ARC opcodes.
   2    Copyright 2015 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 #ifndef INSERT_LIMM
  23 #define INSERT_LIMM
  24 /* mask = 00000000000000000000000000000000
  25    insn = 00100bbb00101111FBBB111110001001.  */
  26 static unsigned
  27 insert_limm (unsigned insn ATTRIBUTE_UNUSED,
  28              int value ATTRIBUTE_UNUSED, const char **errmsg ATTRIBUTE_UNUSED)
  29 {
  30
  31   return insn;
  32 }
  33 #endif /* INSERT_LIMM */
  34
  35 #ifndef EXTRACT_LIMM
  36 #define EXTRACT_LIMM
  37 /* mask = 00000000000000000000000000000000.  */
  38 static ATTRIBUTE_UNUSED int
  39 extract_limm (unsigned insn ATTRIBUTE_UNUSED, bfd_boolean * invalid ATTRIBUTE_UNUSED)
  40 {
  41   unsigned value = 0;
  42
  43   return value;
  44 }
  45 #endif /* EXTRACT_LIMM */
  46
  47 #ifndef INSERT_UIMM6_20
  48 #define INSERT_UIMM6_20
  49 /* mask = 00000000000000000000111111000000
  50    insn = 00100bbb01101111FBBBuuuuuu001001.  */
  51 static unsigned
  52 insert_uimm6_20 (unsigned insn ATTRIBUTE_UNUSED,
  53                  int value ATTRIBUTE_UNUSED,
  54                  const char **errmsg ATTRIBUTE_UNUSED)
  55 {
  56
  57   insn |= ((value >> 0) & 0x003f) << 6;
  58
  59   return insn;
  60 }
  61 #endif /* INSERT_UIMM6_20 */
  62
  63 #ifndef EXTRACT_UIMM6_20
  64 #define EXTRACT_UIMM6_20
  65 /* mask = 00000000000000000000111111000000.  */
  66 static int
  67 extract_uimm6_20 (unsigned insn ATTRIBUTE_UNUSED,
  68                   bfd_boolean * invalid ATTRIBUTE_UNUSED)
  69 {
  70   unsigned value = 0;
  71
  72   value |= ((insn >> 6) & 0x003f) << 0;
  73
  74   return value;
  75 }
  76 #endif /* EXTRACT_UIMM6_20 */
  77
  78 #ifndef INSERT_SIMM12_20
  79 #define INSERT_SIMM12_20
  80 /* mask = 00000000000000000000111111222222
  81    insn = 00110bbb10101000FBBBssssssSSSSSS.  */
  82 static unsigned
  83 insert_simm12_20 (unsigned insn ATTRIBUTE_UNUSED,
  84                   int value ATTRIBUTE_UNUSED,
  85                   const char **errmsg ATTRIBUTE_UNUSED)
  86 {
  87
  88   insn |= ((value >> 0) & 0x003f) << 6;
  89   insn |= ((value >> 6) & 0x003f) << 0;
  90
  91   return insn;
  92 }
  93 #endif /* INSERT_SIMM12_20 */
  94
  95 #ifndef EXTRACT_SIMM12_20
  96 #define EXTRACT_SIMM12_20
  97 /* mask = 00000000000000000000111111222222.  */
  98 static int
  99 extract_simm12_20 (unsigned insn ATTRIBUTE_UNUSED,
 100                    bfd_boolean * invalid ATTRIBUTE_UNUSED)
 101 {
 102   int value = 0;
 103
 104   value |= ((insn >> 6) & 0x003f) << 0;
 105   value |= ((insn >> 0) & 0x003f) << 6;
 106
 107   /* Extend the sign.  */
 108   int signbit = 1 << (12 - 1);
 109   value = (value ^ signbit) - signbit;
 110
 111   return value;
 112 }
 113 #endif /* EXTRACT_SIMM12_20 */
 114
 115 #ifndef INSERT_SIMM3_5_S
 116 #define INSERT_SIMM3_5_S
 117 /* mask = 0000011100000000
 118    insn = 01110ssshhh001HH.  */
 119 static ATTRIBUTE_UNUSED unsigned
 120 insert_simm3_5_s (unsigned insn ATTRIBUTE_UNUSED,
 121                   int value ATTRIBUTE_UNUSED,
 122                   const char **errmsg ATTRIBUTE_UNUSED)
 123 {
 124
 125   insn |= ((value >> 0) & 0x0007) << 8;
 126
 127   return insn;
 128 }
 129 #endif /* INSERT_SIMM3_5_S */
 130
 131 #ifndef EXTRACT_SIMM3_5_S
 132 #define EXTRACT_SIMM3_5_S
 133 /* mask = 0000011100000000.  */
 134 static ATTRIBUTE_UNUSED int
 135 extract_simm3_5_s (unsigned insn ATTRIBUTE_UNUSED,
 136                    bfd_boolean * invalid ATTRIBUTE_UNUSED)
 137 {
 138   int value = 0;
 139
 140   value |= ((insn >> 8) & 0x0007) << 0;
 141
 142   /* Extend the sign.  */
 143   int signbit = 1 << (3 - 1);
 144   value = (value ^ signbit) - signbit;
 145
 146   return value;
 147 }
 148 #endif /* EXTRACT_SIMM3_5_S */
 149
 150 #ifndef INSERT_LIMM_S
 151 #define INSERT_LIMM_S
 152 /* mask = 0000000000000000
 153    insn = 01110sss11000111.  */
 154 static ATTRIBUTE_UNUSED unsigned
 155 insert_limm_s (unsigned insn ATTRIBUTE_UNUSED,
 156                int value ATTRIBUTE_UNUSED,
 157                const char **errmsg ATTRIBUTE_UNUSED)
 158 {
 159
 160   return insn;
 161 }
 162 #endif /* INSERT_LIMM_S */
 163
 164 #ifndef EXTRACT_LIMM_S
 165 #define EXTRACT_LIMM_S
 166 /* mask = 0000000000000000.  */
 167 static ATTRIBUTE_UNUSED int
 168 extract_limm_s (unsigned insn ATTRIBUTE_UNUSED, bfd_boolean * invalid ATTRIBUTE_UNUSED)
 169 {
 170   unsigned value = 0;
 171
 172   return value;
 173 }
 174 #endif /* EXTRACT_LIMM_S */
 175
 176 #ifndef INSERT_UIMM7_A32_11_S
 177 #define INSERT_UIMM7_A32_11_S
 178 /* mask = 0000000000011111
 179    insn = 11000bbb100uuuuu.  */
 180 static unsigned
 181 insert_uimm7_a32_11_s (unsigned insn ATTRIBUTE_UNUSED,
 182                        int value ATTRIBUTE_UNUSED,
 183                        const char **errmsg ATTRIBUTE_UNUSED)
 184 {
 185   if (value & 0x03)
 186     *errmsg = _("Target address is not 32bit aligned.");
 187
 188   insn |= ((value >> 2) & 0x001f) << 0;
 189
 190   return insn;
 191 }
 192 #endif /* INSERT_UIMM7_A32_11_S */
 193
 194 #ifndef EXTRACT_UIMM7_A32_11_S
 195 #define EXTRACT_UIMM7_A32_11_S
 196 /* mask = 0000000000011111.  */
 197 static int
 198 extract_uimm7_a32_11_s (unsigned insn ATTRIBUTE_UNUSED,
 199                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 200 {
 201   unsigned value = 0;
 202
 203   value |= ((insn >> 0) & 0x001f) << 2;
 204
 205   return value;
 206 }
 207 #endif /* EXTRACT_UIMM7_A32_11_S */
 208
 209 #ifndef INSERT_UIMM7_9_S
 210 #define INSERT_UIMM7_9_S
 211 /* mask = 0000000001111111
 212    insn = 11100bbb0uuuuuuu.  */
 213 static unsigned
 214 insert_uimm7_9_s (unsigned insn ATTRIBUTE_UNUSED,
 215                   int value ATTRIBUTE_UNUSED,
 216                   const char **errmsg ATTRIBUTE_UNUSED)
 217 {
 218
 219   insn |= ((value >> 0) & 0x007f) << 0;
 220
 221   return insn;
 222 }
 223 #endif /* INSERT_UIMM7_9_S */
 224
 225 #ifndef EXTRACT_UIMM7_9_S
 226 #define EXTRACT_UIMM7_9_S
 227 /* mask = 0000000001111111.  */
 228 static int
 229 extract_uimm7_9_s (unsigned insn ATTRIBUTE_UNUSED,
 230                    bfd_boolean * invalid ATTRIBUTE_UNUSED)
 231 {
 232   unsigned value = 0;
 233
 234   value |= ((insn >> 0) & 0x007f) << 0;
 235
 236   return value;
 237 }
 238 #endif /* EXTRACT_UIMM7_9_S */
 239
 240 #ifndef INSERT_UIMM3_13_S
 241 #define INSERT_UIMM3_13_S
 242 /* mask = 0000000000000111
 243    insn = 01101bbbccc00uuu.  */
 244 static unsigned
 245 insert_uimm3_13_s (unsigned insn ATTRIBUTE_UNUSED,
 246                    int value ATTRIBUTE_UNUSED,
 247                    const char **errmsg ATTRIBUTE_UNUSED)
 248 {
 249
 250   insn |= ((value >> 0) & 0x0007) << 0;
 251
 252   return insn;
 253 }
 254 #endif /* INSERT_UIMM3_13_S */
 255
 256 #ifndef EXTRACT_UIMM3_13_S
 257 #define EXTRACT_UIMM3_13_S
 258 /* mask = 0000000000000111.  */
 259 static int
 260 extract_uimm3_13_s (unsigned insn ATTRIBUTE_UNUSED,
 261                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
 262 {
 263   unsigned value = 0;
 264
 265   value |= ((insn >> 0) & 0x0007) << 0;
 266
 267   return value;
 268 }
 269 #endif /* EXTRACT_UIMM3_13_S */
 270
 271 #ifndef INSERT_SIMM11_A32_7_S
 272 #define INSERT_SIMM11_A32_7_S
 273 /* mask = 0000000111111111
 274    insn = 1100111sssssssss.  */
 275 static unsigned
 276 insert_simm11_a32_7_s (unsigned insn ATTRIBUTE_UNUSED,
 277                        int value ATTRIBUTE_UNUSED,
 278                        const char **errmsg ATTRIBUTE_UNUSED)
 279 {
 280   if (value & 0x03)
 281     *errmsg = _("Target address is not 32bit aligned.");
 282
 283   insn |= ((value >> 2) & 0x01ff) << 0;
 284
 285   return insn;
 286 }
 287 #endif /* INSERT_SIMM11_A32_7_S */
 288
 289 #ifndef EXTRACT_SIMM11_A32_7_S
 290 #define EXTRACT_SIMM11_A32_7_S
 291 /* mask = 0000000111111111.  */
 292 static int
 293 extract_simm11_a32_7_s (unsigned insn ATTRIBUTE_UNUSED,
 294                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 295 {
 296   int value = 0;
 297
 298   value |= ((insn >> 0) & 0x01ff) << 2;
 299
 300   /* Extend the sign.  */
 301   int signbit = 1 << (11 - 1);
 302   value = (value ^ signbit) - signbit;
 303
 304   return value;
 305 }
 306 #endif /* EXTRACT_SIMM11_A32_7_S */
 307
 308 #ifndef INSERT_UIMM6_13_S
 309 #define INSERT_UIMM6_13_S
 310 /* mask = 0000000002220111
 311    insn = 01001bbb0UUU1uuu.  */
 312 static unsigned
 313 insert_uimm6_13_s (unsigned insn ATTRIBUTE_UNUSED,
 314                    int value ATTRIBUTE_UNUSED,
 315                    const char **errmsg ATTRIBUTE_UNUSED)
 316 {
 317
 318   insn |= ((value >> 0) & 0x0007) << 0;
 319   insn |= ((value >> 3) & 0x0007) << 4;
 320
 321   return insn;
 322 }
 323 #endif /* INSERT_UIMM6_13_S */
 324
 325 #ifndef EXTRACT_UIMM6_13_S
 326 #define EXTRACT_UIMM6_13_S
 327 /* mask = 0000000002220111.  */
 328 static int
 329 extract_uimm6_13_s (unsigned insn ATTRIBUTE_UNUSED,
 330                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
 331 {
 332   unsigned value = 0;
 333
 334   value |= ((insn >> 0) & 0x0007) << 0;
 335   value |= ((insn >> 4) & 0x0007) << 3;
 336
 337   return value;
 338 }
 339 #endif /* EXTRACT_UIMM6_13_S */
 340
 341 #ifndef INSERT_UIMM5_11_S
 342 #define INSERT_UIMM5_11_S
 343 /* mask = 0000000000011111
 344    insn = 10111bbb000uuuuu.  */
 345 static unsigned
 346 insert_uimm5_11_s (unsigned insn ATTRIBUTE_UNUSED,
 347                    int value ATTRIBUTE_UNUSED,
 348                    const char **errmsg ATTRIBUTE_UNUSED)
 349 {
 350
 351   insn |= ((value >> 0) & 0x001f) << 0;
 352
 353   return insn;
 354 }
 355 #endif /* INSERT_UIMM5_11_S */
 356
 357 #ifndef EXTRACT_UIMM5_11_S
 358 #define EXTRACT_UIMM5_11_S
 359 /* mask = 0000000000011111.  */
 360 static int
 361 extract_uimm5_11_s (unsigned insn ATTRIBUTE_UNUSED,
 362                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
 363 {
 364   unsigned value = 0;
 365
 366   value |= ((insn >> 0) & 0x001f) << 0;
 367
 368   return value;
 369 }
 370 #endif /* EXTRACT_UIMM5_11_S */
 371
 372 #ifndef INSERT_SIMM9_A16_8
 373 #define INSERT_SIMM9_A16_8
 374 /* mask = 00000000111111102000000000000000
 375    insn = 00001bbbsssssss1SBBBCCCCCCN01110.  */
 376 static unsigned
 377 insert_simm9_a16_8 (unsigned insn ATTRIBUTE_UNUSED,
 378                     int value ATTRIBUTE_UNUSED,
 379                     const char **errmsg ATTRIBUTE_UNUSED)
 380 {
 381   if (value & 0x01)
 382     *errmsg = _("Target address is not 16bit aligned.");
 383
 384   insn |= ((value >> 1) & 0x007f) << 17;
 385   insn |= ((value >> 8) & 0x0001) << 15;
 386
 387   return insn;
 388 }
 389 #endif /* INSERT_SIMM9_A16_8 */
 390
 391 #ifndef EXTRACT_SIMM9_A16_8
 392 #define EXTRACT_SIMM9_A16_8
 393 /* mask = 00000000111111102000000000000000.  */
 394 static int
 395 extract_simm9_a16_8 (unsigned insn ATTRIBUTE_UNUSED,
 396                      bfd_boolean * invalid ATTRIBUTE_UNUSED)
 397 {
 398   int value = 0;
 399
 400   value |= ((insn >> 17) & 0x007f) << 1;
 401   value |= ((insn >> 15) & 0x0001) << 8;
 402
 403   /* Extend the sign.  */
 404   int signbit = 1 << (9 - 1);
 405   value = (value ^ signbit) - signbit;
 406
 407   return value;
 408 }
 409 #endif /* EXTRACT_SIMM9_A16_8 */
 410
 411 #ifndef INSERT_UIMM6_8
 412 #define INSERT_UIMM6_8
 413 /* mask = 00000000000000000000111111000000
 414    insn = 00001bbbsssssss1SBBBuuuuuuN11110.  */
 415 static unsigned
 416 insert_uimm6_8 (unsigned insn ATTRIBUTE_UNUSED,
 417                 int value ATTRIBUTE_UNUSED,
 418                 const char **errmsg ATTRIBUTE_UNUSED)
 419 {
 420
 421   insn |= ((value >> 0) & 0x003f) << 6;
 422
 423   return insn;
 424 }
 425 #endif /* INSERT_UIMM6_8 */
 426
 427 #ifndef EXTRACT_UIMM6_8
 428 #define EXTRACT_UIMM6_8
 429 /* mask = 00000000000000000000111111000000.  */
 430 static int
 431 extract_uimm6_8 (unsigned insn ATTRIBUTE_UNUSED,
 432                  bfd_boolean * invalid ATTRIBUTE_UNUSED)
 433 {
 434   unsigned value = 0;
 435
 436   value |= ((insn >> 6) & 0x003f) << 0;
 437
 438   return value;
 439 }
 440 #endif /* EXTRACT_UIMM6_8 */
 441
 442 #ifndef INSERT_SIMM21_A16_5
 443 #define INSERT_SIMM21_A16_5
 444 /* mask = 00000111111111102222222222000000
 445    insn = 00000ssssssssss0SSSSSSSSSSNQQQQQ.  */
 446 static unsigned
 447 insert_simm21_a16_5 (unsigned insn ATTRIBUTE_UNUSED,
 448                      int value ATTRIBUTE_UNUSED,
 449                      const char **errmsg ATTRIBUTE_UNUSED)
 450 {
 451   if (value & 0x01)
 452     *errmsg = _("Target address is not 16bit aligned.");
 453
 454   insn |= ((value >> 1) & 0x03ff) << 17;
 455   insn |= ((value >> 11) & 0x03ff) << 6;
 456
 457   return insn;
 458 }
 459 #endif /* INSERT_SIMM21_A16_5 */
 460
 461 #ifndef EXTRACT_SIMM21_A16_5
 462 #define EXTRACT_SIMM21_A16_5
 463 /* mask = 00000111111111102222222222000000.  */
 464 static int
 465 extract_simm21_a16_5 (unsigned insn ATTRIBUTE_UNUSED,
 466                       bfd_boolean * invalid ATTRIBUTE_UNUSED)
 467 {
 468   int value = 0;
 469
 470   value |= ((insn >> 17) & 0x03ff) << 1;
 471   value |= ((insn >> 6) & 0x03ff) << 11;
 472
 473   /* Extend the sign.  */
 474   int signbit = 1 << (21 - 1);
 475   value = (value ^ signbit) - signbit;
 476
 477   return value;
 478 }
 479 #endif /* EXTRACT_SIMM21_A16_5 */
 480
 481 #ifndef INSERT_SIMM25_A16_5
 482 #define INSERT_SIMM25_A16_5
 483 /* mask = 00000111111111102222222222003333
 484    insn = 00000ssssssssss1SSSSSSSSSSNRtttt.  */
 485 static unsigned
 486 insert_simm25_a16_5 (unsigned insn ATTRIBUTE_UNUSED,
 487                      int value ATTRIBUTE_UNUSED,
 488                      const char **errmsg ATTRIBUTE_UNUSED)
 489 {
 490   if (value & 0x01)
 491     *errmsg = _("Target address is not 16bit aligned.");
 492
 493   insn |= ((value >> 1) & 0x03ff) << 17;
 494   insn |= ((value >> 11) & 0x03ff) << 6;
 495   insn |= ((value >> 21) & 0x000f) << 0;
 496
 497   return insn;
 498 }
 499 #endif /* INSERT_SIMM25_A16_5 */
 500
 501 #ifndef EXTRACT_SIMM25_A16_5
 502 #define EXTRACT_SIMM25_A16_5
 503 /* mask = 00000111111111102222222222003333.  */
 504 static int
 505 extract_simm25_a16_5 (unsigned insn ATTRIBUTE_UNUSED,
 506                       bfd_boolean * invalid ATTRIBUTE_UNUSED)
 507 {
 508   int value = 0;
 509
 510   value |= ((insn >> 17) & 0x03ff) << 1;
 511   value |= ((insn >> 6) & 0x03ff) << 11;
 512   value |= ((insn >> 0) & 0x000f) << 21;
 513
 514   /* Extend the sign.  */
 515   int signbit = 1 << (25 - 1);
 516   value = (value ^ signbit) - signbit;
 517
 518   return value;
 519 }
 520 #endif /* EXTRACT_SIMM25_A16_5 */
 521
 522 #ifndef INSERT_SIMM10_A16_7_S
 523 #define INSERT_SIMM10_A16_7_S
 524 /* mask = 0000000111111111
 525    insn = 1111001sssssssss.  */
 526 static unsigned
 527 insert_simm10_a16_7_s (unsigned insn ATTRIBUTE_UNUSED,
 528                        int value ATTRIBUTE_UNUSED,
 529                        const char **errmsg ATTRIBUTE_UNUSED)
 530 {
 531   if (value & 0x01)
 532     *errmsg = _("Target address is not 16bit aligned.");
 533
 534   insn |= ((value >> 1) & 0x01ff) << 0;
 535
 536   return insn;
 537 }
 538 #endif /* INSERT_SIMM10_A16_7_S */
 539
 540 #ifndef EXTRACT_SIMM10_A16_7_S
 541 #define EXTRACT_SIMM10_A16_7_S
 542 /* mask = 0000000111111111.  */
 543 static int
 544 extract_simm10_a16_7_s (unsigned insn ATTRIBUTE_UNUSED,
 545                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 546 {
 547   int value = 0;
 548
 549   value |= ((insn >> 0) & 0x01ff) << 1;
 550
 551   /* Extend the sign.  */
 552   int signbit = 1 << (10 - 1);
 553   value = (value ^ signbit) - signbit;
 554
 555   return value;
 556 }
 557 #endif /* EXTRACT_SIMM10_A16_7_S */
 558
 559 #ifndef INSERT_SIMM7_A16_10_S
 560 #define INSERT_SIMM7_A16_10_S
 561 /* mask = 0000000000111111
 562    insn = 1111011000ssssss.  */
 563 static unsigned
 564 insert_simm7_a16_10_s (unsigned insn ATTRIBUTE_UNUSED,
 565                        int value ATTRIBUTE_UNUSED,
 566                        const char **errmsg ATTRIBUTE_UNUSED)
 567 {
 568   if (value & 0x01)
 569     *errmsg = _("Target address is not 16bit aligned.");
 570
 571   insn |= ((value >> 1) & 0x003f) << 0;
 572
 573   return insn;
 574 }
 575 #endif /* INSERT_SIMM7_A16_10_S */
 576
 577 #ifndef EXTRACT_SIMM7_A16_10_S
 578 #define EXTRACT_SIMM7_A16_10_S
 579 /* mask = 0000000000111111.  */
 580 static int
 581 extract_simm7_a16_10_s (unsigned insn ATTRIBUTE_UNUSED,
 582                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 583 {
 584   int value = 0;
 585
 586   value |= ((insn >> 0) & 0x003f) << 1;
 587
 588   /* Extend the sign.  */
 589   int signbit = 1 << (7 - 1);
 590   value = (value ^ signbit) - signbit;
 591
 592   return value;
 593 }
 594 #endif /* EXTRACT_SIMM7_A16_10_S */
 595
 596 #ifndef INSERT_SIMM21_A32_5
 597 #define INSERT_SIMM21_A32_5
 598 /* mask = 00000111111111002222222222000000
 599    insn = 00001sssssssss00SSSSSSSSSSNQQQQQ.  */
 600 static unsigned
 601 insert_simm21_a32_5 (unsigned insn ATTRIBUTE_UNUSED,
 602                      int value ATTRIBUTE_UNUSED,
 603                      const char **errmsg ATTRIBUTE_UNUSED)
 604 {
 605   if (value & 0x03)
 606     *errmsg = _("Target address is not 32bit aligned.");
 607
 608   insn |= ((value >> 2) & 0x01ff) << 18;
 609   insn |= ((value >> 11) & 0x03ff) << 6;
 610
 611   return insn;
 612 }
 613 #endif /* INSERT_SIMM21_A32_5 */
 614
 615 #ifndef EXTRACT_SIMM21_A32_5
 616 #define EXTRACT_SIMM21_A32_5
 617 /* mask = 00000111111111002222222222000000.  */
 618 static int
 619 extract_simm21_a32_5 (unsigned insn ATTRIBUTE_UNUSED,
 620                       bfd_boolean * invalid ATTRIBUTE_UNUSED)
 621 {
 622   int value = 0;
 623
 624   value |= ((insn >> 18) & 0x01ff) << 2;
 625   value |= ((insn >> 6) & 0x03ff) << 11;
 626
 627   /* Extend the sign.  */
 628   int signbit = 1 << (21 - 1);
 629   value = (value ^ signbit) - signbit;
 630
 631   return value;
 632 }
 633 #endif /* EXTRACT_SIMM21_A32_5 */
 634
 635 #ifndef INSERT_SIMM25_A32_5
 636 #define INSERT_SIMM25_A32_5
 637 /* mask = 00000111111111002222222222003333
 638    insn = 00001sssssssss10SSSSSSSSSSNRtttt.  */
 639 static unsigned
 640 insert_simm25_a32_5 (unsigned insn ATTRIBUTE_UNUSED,
 641                      int value ATTRIBUTE_UNUSED,
 642                      const char **errmsg ATTRIBUTE_UNUSED)
 643 {
 644   if (value & 0x03)
 645     *errmsg = _("Target address is not 32bit aligned.");
 646
 647   insn |= ((value >> 2) & 0x01ff) << 18;
 648   insn |= ((value >> 11) & 0x03ff) << 6;
 649   insn |= ((value >> 21) & 0x000f) << 0;
 650
 651   return insn;
 652 }
 653 #endif /* INSERT_SIMM25_A32_5 */
 654
 655 #ifndef EXTRACT_SIMM25_A32_5
 656 #define EXTRACT_SIMM25_A32_5
 657 /* mask = 00000111111111002222222222003333.  */
 658 static int
 659 extract_simm25_a32_5 (unsigned insn ATTRIBUTE_UNUSED,
 660                       bfd_boolean * invalid ATTRIBUTE_UNUSED)
 661 {
 662   int value = 0;
 663
 664   value |= ((insn >> 18) & 0x01ff) << 2;
 665   value |= ((insn >> 6) & 0x03ff) << 11;
 666   value |= ((insn >> 0) & 0x000f) << 21;
 667
 668   /* Extend the sign.  */
 669   int signbit = 1 << (25 - 1);
 670   value = (value ^ signbit) - signbit;
 671
 672   return value;
 673 }
 674 #endif /* EXTRACT_SIMM25_A32_5 */
 675
 676 #ifndef INSERT_SIMM13_A32_5_S
 677 #define INSERT_SIMM13_A32_5_S
 678 /* mask = 0000011111111111
 679    insn = 11111sssssssssss.  */
 680 static unsigned
 681 insert_simm13_a32_5_s (unsigned insn ATTRIBUTE_UNUSED,
 682                        int value ATTRIBUTE_UNUSED,
 683                        const char **errmsg ATTRIBUTE_UNUSED)
 684 {
 685   if (value & 0x03)
 686     *errmsg = _("Target address is not 32bit aligned.");
 687
 688   insn |= ((value >> 2) & 0x07ff) << 0;
 689
 690   return insn;
 691 }
 692 #endif /* INSERT_SIMM13_A32_5_S */
 693
 694 #ifndef EXTRACT_SIMM13_A32_5_S
 695 #define EXTRACT_SIMM13_A32_5_S
 696 /* mask = 0000011111111111.  */
 697 static int
 698 extract_simm13_a32_5_s (unsigned insn ATTRIBUTE_UNUSED,
 699                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 700 {
 701   int value = 0;
 702
 703   value |= ((insn >> 0) & 0x07ff) << 2;
 704
 705   /* Extend the sign.  */
 706   int signbit = 1 << (13 - 1);
 707   value = (value ^ signbit) - signbit;
 708
 709   return value;
 710 }
 711 #endif /* EXTRACT_SIMM13_A32_5_S */
 712
 713 #ifndef INSERT_SIMM8_A16_9_S
 714 #define INSERT_SIMM8_A16_9_S
 715 /* mask = 0000000001111111
 716    insn = 11101bbb1sssssss.  */
 717 static unsigned
 718 insert_simm8_a16_9_s (unsigned insn ATTRIBUTE_UNUSED,
 719                       int value ATTRIBUTE_UNUSED,
 720                       const char **errmsg ATTRIBUTE_UNUSED)
 721 {
 722   if (value & 0x01)
 723     *errmsg = _("Target address is not 16bit aligned.");
 724
 725   insn |= ((value >> 1) & 0x007f) << 0;
 726
 727   return insn;
 728 }
 729 #endif /* INSERT_SIMM8_A16_9_S */
 730
 731 #ifndef EXTRACT_SIMM8_A16_9_S
 732 #define EXTRACT_SIMM8_A16_9_S
 733 /* mask = 0000000001111111.  */
 734 static int
 735 extract_simm8_a16_9_s (unsigned insn ATTRIBUTE_UNUSED,
 736                        bfd_boolean * invalid ATTRIBUTE_UNUSED)
 737 {
 738   int value = 0;
 739
 740   value |= ((insn >> 0) & 0x007f) << 1;
 741
 742   /* Extend the sign.  */
 743   int signbit = 1 << (8 - 1);
 744   value = (value ^ signbit) - signbit;
 745
 746   return value;
 747 }
 748 #endif /* EXTRACT_SIMM8_A16_9_S */
 749
 750 #ifndef INSERT_UIMM3_23
 751 #define INSERT_UIMM3_23
 752 /* mask = 00000000000000000000000111000000
 753    insn = 00100011011011110001RRRuuu111111.  */
 754 static unsigned
 755 insert_uimm3_23 (unsigned insn ATTRIBUTE_UNUSED,
 756                  int value ATTRIBUTE_UNUSED,
 757                  const char **errmsg ATTRIBUTE_UNUSED)
 758 {
 759
 760   insn |= ((value >> 0) & 0x0007) << 6;
 761
 762   return insn;
 763 }
 764 #endif /* INSERT_UIMM3_23 */
 765
 766 #ifndef EXTRACT_UIMM3_23
 767 #define EXTRACT_UIMM3_23
 768 /* mask = 00000000000000000000000111000000.  */
 769 static int
 770 extract_uimm3_23 (unsigned insn ATTRIBUTE_UNUSED,
 771                   bfd_boolean * invalid ATTRIBUTE_UNUSED)
 772 {
 773   unsigned value = 0;
 774
 775   value |= ((insn >> 6) & 0x0007) << 0;
 776
 777   return value;
 778 }
 779 #endif /* EXTRACT_UIMM3_23 */
 780
 781 #ifndef INSERT_UIMM10_6_S
 782 #define INSERT_UIMM10_6_S
 783 /* mask = 0000001111111111
 784    insn = 010111uuuuuuuuuu.  */
 785 static unsigned
 786 insert_uimm10_6_s (unsigned insn ATTRIBUTE_UNUSED,
 787                    int value ATTRIBUTE_UNUSED,
 788                    const char **errmsg ATTRIBUTE_UNUSED)
 789 {
 790
 791   insn |= ((value >> 0) & 0x03ff) << 0;
 792
 793   return insn;
 794 }
 795 #endif /* INSERT_UIMM10_6_S */
 796
 797 #ifndef EXTRACT_UIMM10_6_S
 798 #define EXTRACT_UIMM10_6_S
 799 /* mask = 0000001111111111.  */
 800 static int
 801 extract_uimm10_6_s (unsigned insn ATTRIBUTE_UNUSED,
 802                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
 803 {
 804   unsigned value = 0;
 805
 806   value |= ((insn >> 0) & 0x03ff) << 0;
 807
 808   return value;
 809 }
 810 #endif /* EXTRACT_UIMM10_6_S */
 811
 812 #ifndef INSERT_UIMM6_11_S
 813 #define INSERT_UIMM6_11_S
 814 /* mask = 0000002200011110
 815    insn = 110000UU111uuuu0.  */
 816 static unsigned
 817 insert_uimm6_11_s (unsigned insn ATTRIBUTE_UNUSED,
 818                    int value ATTRIBUTE_UNUSED,
 819                    const char **errmsg ATTRIBUTE_UNUSED)
 820 {
 821
 822   insn |= ((value >> 0) & 0x000f) << 1;
 823   insn |= ((value >> 4) & 0x0003) << 8;
 824
 825   return insn;
 826 }
 827 #endif /* INSERT_UIMM6_11_S */
 828
 829 #ifndef EXTRACT_UIMM6_11_S
 830 #define EXTRACT_UIMM6_11_S
 831 /* mask = 0000002200011110.  */
 832 static int
 833 extract_uimm6_11_s (unsigned insn ATTRIBUTE_UNUSED,
 834                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
 835 {
 836   unsigned value = 0;
 837
 838   value |= ((insn >> 1) & 0x000f) << 0;
 839   value |= ((insn >> 8) & 0x0003) << 4;
 840
 841   return value;
 842 }
 843 #endif /* EXTRACT_UIMM6_11_S */
 844
 845 #ifndef INSERT_SIMM9_8
 846 #define INSERT_SIMM9_8
 847 /* mask = 00000000111111112000000000000000
 848    insn = 00010bbbssssssssSBBBDaaZZXAAAAAA.  */
 849 static unsigned
 850 insert_simm9_8 (unsigned insn ATTRIBUTE_UNUSED,
 851                 int value ATTRIBUTE_UNUSED,
 852                 const char **errmsg ATTRIBUTE_UNUSED)
 853 {
 854
 855   insn |= ((value >> 0) & 0x00ff) << 16;
 856   insn |= ((value >> 8) & 0x0001) << 15;
 857
 858   return insn;
 859 }
 860 #endif /* INSERT_SIMM9_8 */
 861
 862 #ifndef EXTRACT_SIMM9_8
 863 #define EXTRACT_SIMM9_8
 864 /* mask = 00000000111111112000000000000000.  */
 865 static int
 866 extract_simm9_8 (unsigned insn ATTRIBUTE_UNUSED,
 867                  bfd_boolean * invalid ATTRIBUTE_UNUSED)
 868 {
 869   int value = 0;
 870
 871   value |= ((insn >> 16) & 0x00ff) << 0;
 872   value |= ((insn >> 15) & 0x0001) << 8;
 873
 874   /* Extend the sign.  */
 875   int signbit = 1 << (9 - 1);
 876   value = (value ^ signbit) - signbit;
 877
 878   return value;
 879 }
 880 #endif /* EXTRACT_SIMM9_8 */
 881
 882 #ifndef INSERT_UIMM10_A32_8_S
 883 #define INSERT_UIMM10_A32_8_S
 884 /* mask = 0000000011111111
 885    insn = 11010bbbuuuuuuuu.  */
 886 static unsigned
 887 insert_uimm10_a32_8_s (unsigned insn ATTRIBUTE_UNUSED,
 888                        int value ATTRIBUTE_UNUSED,
 889                        const char **errmsg ATTRIBUTE_UNUSED)
 890 {
 891   if (value & 0x03)
 892     *errmsg = _("Target address is not 32bit aligned.");
 893
 894   insn |= ((value >> 2) & 0x00ff) << 0;
 895
 896   return insn;
 897 }
 898 #endif /* INSERT_UIMM10_A32_8_S */
 899
 900 #ifndef EXTRACT_UIMM10_A32_8_S
 901 #define EXTRACT_UIMM10_A32_8_S
 902 /* mask = 0000000011111111.  */
 903 static int
 904 extract_uimm10_a32_8_s (unsigned insn ATTRIBUTE_UNUSED,
 905                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 906 {
 907   unsigned value = 0;
 908
 909   value |= ((insn >> 0) & 0x00ff) << 2;
 910
 911   return value;
 912 }
 913 #endif /* EXTRACT_UIMM10_A32_8_S */
 914
 915 #ifndef INSERT_SIMM9_7_S
 916 #define INSERT_SIMM9_7_S
 917 /* mask = 0000000111111111
 918    insn = 1100101sssssssss.  */
 919 static unsigned
 920 insert_simm9_7_s (unsigned insn ATTRIBUTE_UNUSED,
 921                   int value ATTRIBUTE_UNUSED,
 922                   const char **errmsg ATTRIBUTE_UNUSED)
 923 {
 924
 925   insn |= ((value >> 0) & 0x01ff) << 0;
 926
 927   return insn;
 928 }
 929 #endif /* INSERT_SIMM9_7_S */
 930
 931 #ifndef EXTRACT_SIMM9_7_S
 932 #define EXTRACT_SIMM9_7_S
 933 /* mask = 0000000111111111.  */
 934 static int
 935 extract_simm9_7_s (unsigned insn ATTRIBUTE_UNUSED,
 936                    bfd_boolean * invalid ATTRIBUTE_UNUSED)
 937 {
 938   int value = 0;
 939
 940   value |= ((insn >> 0) & 0x01ff) << 0;
 941
 942   /* Extend the sign.  */
 943   int signbit = 1 << (9 - 1);
 944   value = (value ^ signbit) - signbit;
 945
 946   return value;
 947 }
 948 #endif /* EXTRACT_SIMM9_7_S */
 949
 950 #ifndef INSERT_UIMM6_A16_11_S
 951 #define INSERT_UIMM6_A16_11_S
 952 /* mask = 0000000000011111
 953    insn = 10010bbbcccuuuuu.  */
 954 static unsigned
 955 insert_uimm6_a16_11_s (unsigned insn ATTRIBUTE_UNUSED,
 956                        int value ATTRIBUTE_UNUSED,
 957                        const char **errmsg ATTRIBUTE_UNUSED)
 958 {
 959   if (value & 0x01)
 960     *errmsg = _("Target address is not 16bit aligned.");
 961
 962   insn |= ((value >> 1) & 0x001f) << 0;
 963
 964   return insn;
 965 }
 966 #endif /* INSERT_UIMM6_A16_11_S */
 967
 968 #ifndef EXTRACT_UIMM6_A16_11_S
 969 #define EXTRACT_UIMM6_A16_11_S
 970 /* mask = 0000000000011111.  */
 971 static int
 972 extract_uimm6_a16_11_s (unsigned insn ATTRIBUTE_UNUSED,
 973                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
 974 {
 975   unsigned value = 0;
 976
 977   value |= ((insn >> 0) & 0x001f) << 1;
 978
 979   return value;
 980 }
 981 #endif /* EXTRACT_UIMM6_A16_11_S */
 982
 983 #ifndef INSERT_UIMM5_A32_11_S
 984 #define INSERT_UIMM5_A32_11_S
 985 /* mask = 0000020000011000
 986    insn = 01000U00hhhuu1HH.  */
 987 static unsigned
 988 insert_uimm5_a32_11_s (unsigned insn ATTRIBUTE_UNUSED,
 989                        int value ATTRIBUTE_UNUSED,
 990                        const char **errmsg ATTRIBUTE_UNUSED)
 991 {
 992   if (value & 0x03)
 993     *errmsg = _("Target address is not 32bit aligned.");
 994
 995   insn |= ((value >> 2) & 0x0003) << 3;
 996   insn |= ((value >> 4) & 0x0001) << 10;
 997
 998   return insn;
 999 }
1000 #endif /* INSERT_UIMM5_A32_11_S */
1001
1002 #ifndef EXTRACT_UIMM5_A32_11_S
1003 #define EXTRACT_UIMM5_A32_11_S
1004 /* mask = 0000020000011000.  */
1005 static int
1006 extract_uimm5_a32_11_s (unsigned insn ATTRIBUTE_UNUSED,
1007                         bfd_boolean * invalid ATTRIBUTE_UNUSED)
1008 {
1009   unsigned value = 0;
1010
1011   value |= ((insn >> 3) & 0x0003) << 2;
1012   value |= ((insn >> 10) & 0x0001) << 4;
1013
1014   return value;
1015 }
1016 #endif /* EXTRACT_UIMM5_A32_11_S */
1017
1018 #ifndef INSERT_SIMM11_A32_13_S
1019 #define INSERT_SIMM11_A32_13_S
1020 /* mask = 0000022222200111
1021    insn = 01010SSSSSS00sss.  */
1022 static unsigned
1023 insert_simm11_a32_13_s (unsigned insn ATTRIBUTE_UNUSED,
1024                         int value ATTRIBUTE_UNUSED,
1025                         const char **errmsg ATTRIBUTE_UNUSED)
1026 {
1027   if (value & 0x03)
1028     *errmsg = _("Target address is not 32bit aligned.");
1029
1030   insn |= ((value >> 2) & 0x0007) << 0;
1031   insn |= ((value >> 5) & 0x003f) << 5;
1032
1033   return insn;
1034 }
1035 #endif /* INSERT_SIMM11_A32_13_S */
1036
1037 #ifndef EXTRACT_SIMM11_A32_13_S
1038 #define EXTRACT_SIMM11_A32_13_S
1039 /* mask = 0000022222200111.  */
1040 static int
1041 extract_simm11_a32_13_s (unsigned insn ATTRIBUTE_UNUSED,
1042                          bfd_boolean * invalid ATTRIBUTE_UNUSED)
1043 {
1044   int value = 0;
1045
1046   value |= ((insn >> 0) & 0x0007) << 2;
1047   value |= ((insn >> 5) & 0x003f) << 5;
1048
1049   /* Extend the sign.  */
1050   int signbit = 1 << (11 - 1);
1051   value = (value ^ signbit) - signbit;
1052
1053   return value;
1054 }
1055 #endif /* EXTRACT_SIMM11_A32_13_S */
1056
1057 #ifndef INSERT_UIMM7_13_S
1058 #define INSERT_UIMM7_13_S
1059 /* mask = 0000000022220111
1060    insn = 01010bbbUUUU1uuu.  */
1061 static unsigned
1062 insert_uimm7_13_s (unsigned insn ATTRIBUTE_UNUSED,
1063                    int value ATTRIBUTE_UNUSED,
1064                    const char **errmsg ATTRIBUTE_UNUSED)
1065 {
1066
1067   insn |= ((value >> 0) & 0x0007) << 0;
1068   insn |= ((value >> 3) & 0x000f) << 4;
1069
1070   return insn;
1071 }
1072 #endif /* INSERT_UIMM7_13_S */
1073
1074 #ifndef EXTRACT_UIMM7_13_S
1075 #define EXTRACT_UIMM7_13_S
1076 /* mask = 0000000022220111.  */
1077 static int
1078 extract_uimm7_13_s (unsigned insn ATTRIBUTE_UNUSED,
1079                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
1080 {
1081   unsigned value = 0;
1082
1083   value |= ((insn >> 0) & 0x0007) << 0;
1084   value |= ((insn >> 4) & 0x000f) << 3;
1085
1086   return value;
1087 }
1088 #endif /* EXTRACT_UIMM7_13_S */
1089
1090 #ifndef INSERT_UIMM6_A16_21
1091 #define INSERT_UIMM6_A16_21
1092 /* mask = 00000000000000000000011111000000
1093    insn = 00101bbb01001100RBBBRuuuuuAAAAAA.  */
1094 static unsigned
1095 insert_uimm6_a16_21 (unsigned insn ATTRIBUTE_UNUSED,
1096                      int value ATTRIBUTE_UNUSED,
1097                      const char **errmsg ATTRIBUTE_UNUSED)
1098 {
1099   if (value & 0x01)
1100     *errmsg = _("Target address is not 16bit aligned.");
1101
1102   insn |= ((value >> 1) & 0x001f) << 6;
1103
1104   return insn;
1105 }
1106 #endif /* INSERT_UIMM6_A16_21 */
1107
1108 #ifndef EXTRACT_UIMM6_A16_21
1109 #define EXTRACT_UIMM6_A16_21
1110 /* mask = 00000000000000000000011111000000.  */
1111 static int
1112 extract_uimm6_a16_21 (unsigned insn ATTRIBUTE_UNUSED,
1113                       bfd_boolean * invalid ATTRIBUTE_UNUSED)
1114 {
1115   unsigned value = 0;
1116
1117   value |= ((insn >> 6) & 0x001f) << 1;
1118
1119   return value;
1120 }
1121 #endif /* EXTRACT_UIMM6_A16_21 */
1122
1123 #ifndef INSERT_UIMM7_11_S
1124 #define INSERT_UIMM7_11_S
1125 /* mask = 0000022200011110
1126    insn = 11000UUU110uuuu0.  */
1127 static unsigned
1128 insert_uimm7_11_s (unsigned insn ATTRIBUTE_UNUSED,
1129                    int value ATTRIBUTE_UNUSED,
1130                    const char **errmsg ATTRIBUTE_UNUSED)
1131 {
1132
1133   insn |= ((value >> 0) & 0x000f) << 1;
1134   insn |= ((value >> 4) & 0x0007) << 8;
1135
1136   return insn;
1137 }
1138 #endif /* INSERT_UIMM7_11_S */
1139
1140 #ifndef EXTRACT_UIMM7_11_S
1141 #define EXTRACT_UIMM7_11_S
1142 /* mask = 0000022200011110.  */
1143 static int
1144 extract_uimm7_11_s (unsigned insn ATTRIBUTE_UNUSED,
1145                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
1146 {
1147   unsigned value = 0;
1148
1149   value |= ((insn >> 1) & 0x000f) << 0;
1150   value |= ((insn >> 8) & 0x0007) << 4;
1151
1152   return value;
1153 }
1154 #endif /* EXTRACT_UIMM7_11_S */
1155
1156 #ifndef INSERT_UIMM7_A16_20
1157 #define INSERT_UIMM7_A16_20
1158 /* mask = 00000000000000000000111111000000
1159    insn = 00100RRR111010000RRRuuuuuu1QQQQQ.  */
1160 static unsigned
1161 insert_uimm7_a16_20 (unsigned insn ATTRIBUTE_UNUSED,
1162                      int value ATTRIBUTE_UNUSED,
1163                      const char **errmsg ATTRIBUTE_UNUSED)
1164 {
1165   if (value & 0x01)
1166     *errmsg = _("Target address is not 16bit aligned.");
1167
1168   insn |= ((value >> 1) & 0x003f) << 6;
1169
1170   return insn;
1171 }
1172 #endif /* INSERT_UIMM7_A16_20 */
1173
1174 #ifndef EXTRACT_UIMM7_A16_20
1175 #define EXTRACT_UIMM7_A16_20
1176 /* mask = 00000000000000000000111111000000.  */
1177 static int
1178 extract_uimm7_a16_20 (unsigned insn ATTRIBUTE_UNUSED,
1179                       bfd_boolean * invalid ATTRIBUTE_UNUSED)
1180 {
1181   unsigned value = 0;
1182
1183   value |= ((insn >> 6) & 0x003f) << 1;
1184
1185   return value;
1186 }
1187 #endif /* EXTRACT_UIMM7_A16_20 */
1188
1189 #ifndef INSERT_SIMM13_A16_20
1190 #define INSERT_SIMM13_A16_20
1191 /* mask = 00000000000000000000111111222222
1192    insn = 00100RRR101010000RRRssssssSSSSSS.  */
1193 static unsigned
1194 insert_simm13_a16_20 (unsigned insn ATTRIBUTE_UNUSED,
1195                       int value ATTRIBUTE_UNUSED,
1196                       const char **errmsg ATTRIBUTE_UNUSED)
1197 {
1198   if (value & 0x01)
1199     *errmsg = _("Target address is not 16bit aligned.");
1200
1201   insn |= ((value >> 1) & 0x003f) << 6;
1202   insn |= ((value >> 7) & 0x003f) << 0;
1203
1204   return insn;
1205 }
1206 #endif /* INSERT_SIMM13_A16_20 */
1207
1208 #ifndef EXTRACT_SIMM13_A16_20
1209 #define EXTRACT_SIMM13_A16_20
1210 /* mask = 00000000000000000000111111222222.  */
1211 static int
1212 extract_simm13_a16_20 (unsigned insn ATTRIBUTE_UNUSED,
1213                        bfd_boolean * invalid ATTRIBUTE_UNUSED)
1214 {
1215   int value = 0;
1216
1217   value |= ((insn >> 6) & 0x003f) << 1;
1218   value |= ((insn >> 0) & 0x003f) << 7;
1219
1220   /* Extend the sign.  */
1221   int signbit = 1 << (13 - 1);
1222   value = (value ^ signbit) - signbit;
1223
1224   return value;
1225 }
1226 #endif /* EXTRACT_SIMM13_A16_20 */
1227
1228 #ifndef INSERT_UIMM8_8_S
1229 #define INSERT_UIMM8_8_S
1230 /* mask = 0000000011111111
1231    insn = 11011bbbuuuuuuuu.  */
1232 static unsigned
1233 insert_uimm8_8_s (unsigned insn ATTRIBUTE_UNUSED,
1234                   int value ATTRIBUTE_UNUSED,
1235                   const char **errmsg ATTRIBUTE_UNUSED)
1236 {
1237
1238   insn |= ((value >> 0) & 0x00ff) << 0;
1239
1240   return insn;
1241 }
1242 #endif /* INSERT_UIMM8_8_S */
1243
1244 #ifndef EXTRACT_UIMM8_8_S
1245 #define EXTRACT_UIMM8_8_S
1246 /* mask = 0000000011111111.  */
1247 static int
1248 extract_uimm8_8_s (unsigned insn ATTRIBUTE_UNUSED,
1249                    bfd_boolean * invalid ATTRIBUTE_UNUSED)
1250 {
1251   unsigned value = 0;
1252
1253   value |= ((insn >> 0) & 0x00ff) << 0;
1254
1255   return value;
1256 }
1257 #endif /* EXTRACT_UIMM8_8_S */
1258
1259 #ifndef INSERT_UIMM6_5_S
1260 #define INSERT_UIMM6_5_S
1261 /* mask = 0000011111100000
1262    insn = 01111uuuuuu11111.  */
1263 static unsigned
1264 insert_uimm6_5_s (unsigned insn ATTRIBUTE_UNUSED,
1265                   int value ATTRIBUTE_UNUSED,
1266                   const char **errmsg ATTRIBUTE_UNUSED)
1267 {
1268
1269   insn |= ((value >> 0) & 0x003f) << 5;
1270
1271   return insn;
1272 }
1273 #endif /* INSERT_UIMM6_5_S */
1274
1275 #ifndef EXTRACT_UIMM6_5_S
1276 #define EXTRACT_UIMM6_5_S
1277 /* mask = 0000011111100000.  */
1278 static int
1279 extract_uimm6_5_s (unsigned insn ATTRIBUTE_UNUSED,
1280                    bfd_boolean * invalid ATTRIBUTE_UNUSED)
1281 {
1282   unsigned value = 0;
1283
1284   value |= ((insn >> 5) & 0x003f) << 0;
1285
1286   return value;
1287 }
1288 #endif /* EXTRACT_UIMM6_5_S */
1289
1290 #ifndef INSERT_UIMM6_AXX_
1291 #define INSERT_UIMM6_AXX_
1292 /* mask = 00000000000000000000000000000000
1293    insn = 00110bbb11100001100001100001QQQQ.  */
1294 static ATTRIBUTE_UNUSED unsigned
1295 insert_uimm6_axx_ (unsigned insn ATTRIBUTE_UNUSED,
1296                    int value ATTRIBUTE_UNUSED,
1297                    const char **errmsg ATTRIBUTE_UNUSED)
1298 {
1299   if (value & 0x3f)
1300     *errmsg = _("Target address is not 512bit aligned.");
1301
1302   return insn;
1303 }
1304 #endif /* INSERT_UIMM6_AXX_ */
1305
1306 #ifndef EXTRACT_UIMM6_AXX_
1307 #define EXTRACT_UIMM6_AXX_
1308 /* mask = 00000000000000000000000000000000.  */
1309 static ATTRIBUTE_UNUSED int
1310 extract_uimm6_axx_ (unsigned insn ATTRIBUTE_UNUSED,
1311                     bfd_boolean * invalid ATTRIBUTE_UNUSED)
1312 {
1313   unsigned value = 0;
1314
1315   return value;
1316 }
1317 #endif /* EXTRACT_UIMM6_AXX_ */