opcodes/arc-fxi.h

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