src/arch/gcn3/insts/instructions.hh

   1 /*
   2  * Copyright (c) 2015-2017 Advanced Micro Devices, Inc.
   3  * All rights reserved.
   4  *
   5  * For use for simulation and test purposes only
   6  *
   7  * Redistribution and use in source and binary forms, with or without
   8  * modification, are permitted provided that the following conditions are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright notice,
  11  * this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright notice,
  14  * this list of conditions and the following disclaimer in the documentation
  15  * and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the copyright holder nor the names of its
  18  * contributors may be used to endorse or promote products derived from this
  19  * software without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  22  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  28  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  29  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  30  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  31  * POSSIBILITY OF SUCH DAMAGE.
  32  *
  33  * Authors: Anthony Gutierrez
  34  */
  35
  36 #ifndef __ARCH_GCN3_INSTS_INSTRUCTIONS_HH__
  37 #define __ARCH_GCN3_INSTS_INSTRUCTIONS_HH__
  38
  39 #include "arch/gcn3/gpu_decoder.hh"
  40 #include "arch/gcn3/insts/gpu_static_inst.hh"
  41 #include "arch/gcn3/insts/op_encodings.hh"
  42 #include "debug/GCN3.hh"
  43
  44 namespace Gcn3ISA
  45 {
  46     class Inst_SOP2__S_ADD_U32 : public Inst_SOP2
  47     {
  48       public:
  49         Inst_SOP2__S_ADD_U32(InFmt_SOP2*);
  50         ~Inst_SOP2__S_ADD_U32();
  51
  52         int
  53         getNumOperands() override
  54         {
  55             return numDstRegOperands() + numSrcRegOperands();
  56         } // getNumOperands
  57
  58         int numDstRegOperands() override { return 1; }
  59         int numSrcRegOperands() override { return 2; }
  60
  61         int
  62         getOperandSize(int opIdx) override
  63         {
  64             switch (opIdx) {
  65               case 0: //ssrc_0
  66                 return 4;
  67               case 1: //ssrc_1
  68                 return 4;
  69               case 2: //sdst
  70                 return 4;
  71               default:
  72                 fatal("op idx %i out of bounds\n", opIdx);
  73                 return -1;
  74             }
  75         } // getOperandSize
  76
  77         bool
  78         isSrcOperand(int opIdx) override
  79         {
  80             switch (opIdx) {
  81               case 0: //ssrc_0
  82                 return true;
  83               case 1: //ssrc_1
  84                 return true;
  85               case 2: //sdst
  86                 return false;
  87               default:
  88                 fatal("op idx %i out of bounds\n", opIdx);
  89                 return false;
  90             }
  91         } // isSrcOperand
  92
  93         bool
  94         isDstOperand(int opIdx) override
  95         {
  96             switch (opIdx) {
  97               case 0: //ssrc_0
  98                 return false;
  99               case 1: //ssrc_1
 100                 return false;
 101               case 2: //sdst
 102                 return true;
 103               default:
 104                 fatal("op idx %i out of bounds\n", opIdx);
 105                 return false;
 106             }
 107         } // isDstOperand
 108
 109         void execute(GPUDynInstPtr) override;
 110     }; // Inst_SOP2__S_ADD_U32
 111
 112     class Inst_SOP2__S_SUB_U32 : public Inst_SOP2
 113     {
 114       public:
 115         Inst_SOP2__S_SUB_U32(InFmt_SOP2*);
 116         ~Inst_SOP2__S_SUB_U32();
 117
 118         int
 119         getNumOperands() override
 120         {
 121             return numDstRegOperands() + numSrcRegOperands();
 122         } // getNumOperands
 123
 124         int numDstRegOperands() override { return 1; }
 125         int numSrcRegOperands() override { return 2; }
 126
 127         int
 128         getOperandSize(int opIdx) override
 129         {
 130             switch (opIdx) {
 131               case 0: //ssrc_0
 132                 return 4;
 133               case 1: //ssrc_1
 134                 return 4;
 135               case 2: //sdst
 136                 return 4;
 137               default:
 138                 fatal("op idx %i out of bounds\n", opIdx);
 139                 return -1;
 140             }
 141         } // getOperandSize
 142
 143         bool
 144         isSrcOperand(int opIdx) override
 145         {
 146             switch (opIdx) {
 147               case 0: //ssrc_0
 148                 return true;
 149               case 1: //ssrc_1
 150                 return true;
 151               case 2: //sdst
 152                 return false;
 153               default:
 154                 fatal("op idx %i out of bounds\n", opIdx);
 155                 return false;
 156             }
 157         } // isSrcOperand
 158
 159         bool
 160         isDstOperand(int opIdx) override
 161         {
 162             switch (opIdx) {
 163               case 0: //ssrc_0
 164                 return false;
 165               case 1: //ssrc_1
 166                 return false;
 167               case 2: //sdst
 168                 return true;
 169               default:
 170                 fatal("op idx %i out of bounds\n", opIdx);
 171                 return false;
 172             }
 173         } // isDstOperand
 174
 175         void execute(GPUDynInstPtr) override;
 176     }; // Inst_SOP2__S_SUB_U32
 177
 178     class Inst_SOP2__S_ADD_I32 : public Inst_SOP2
 179     {
 180       public:
 181         Inst_SOP2__S_ADD_I32(InFmt_SOP2*);
 182         ~Inst_SOP2__S_ADD_I32();
 183
 184         int
 185         getNumOperands() override
 186         {
 187             return numDstRegOperands() + numSrcRegOperands();
 188         } // getNumOperands
 189
 190         int numDstRegOperands() override { return 1; }
 191         int numSrcRegOperands() override { return 2; }
 192
 193         int
 194         getOperandSize(int opIdx) override
 195         {
 196             switch (opIdx) {
 197               case 0: //ssrc_0
 198                 return 4;
 199               case 1: //ssrc_1
 200                 return 4;
 201               case 2: //sdst
 202                 return 4;
 203               default:
 204                 fatal("op idx %i out of bounds\n", opIdx);
 205                 return -1;
 206             }
 207         } // getOperandSize
 208
 209         bool
 210         isSrcOperand(int opIdx) override
 211         {
 212             switch (opIdx) {
 213               case 0: //ssrc_0
 214                 return true;
 215               case 1: //ssrc_1
 216                 return true;
 217               case 2: //sdst
 218                 return false;
 219               default:
 220                 fatal("op idx %i out of bounds\n", opIdx);
 221                 return false;
 222             }
 223         } // isSrcOperand
 224
 225         bool
 226         isDstOperand(int opIdx) override
 227         {
 228             switch (opIdx) {
 229               case 0: //ssrc_0
 230                 return false;
 231               case 1: //ssrc_1
 232                 return false;
 233               case 2: //sdst
 234                 return true;
 235               default:
 236                 fatal("op idx %i out of bounds\n", opIdx);
 237                 return false;
 238             }
 239         } // isDstOperand
 240
 241         void execute(GPUDynInstPtr) override;
 242     }; // Inst_SOP2__S_ADD_I32
 243
 244     class Inst_SOP2__S_SUB_I32 : public Inst_SOP2
 245     {
 246       public:
 247         Inst_SOP2__S_SUB_I32(InFmt_SOP2*);
 248         ~Inst_SOP2__S_SUB_I32();
 249
 250         int
 251         getNumOperands() override
 252         {
 253             return numDstRegOperands() + numSrcRegOperands();
 254         } // getNumOperands
 255
 256         int numDstRegOperands() override { return 1; }
 257         int numSrcRegOperands() override { return 2; }
 258
 259         int
 260         getOperandSize(int opIdx) override
 261         {
 262             switch (opIdx) {
 263               case 0: //ssrc_0
 264                 return 4;
 265               case 1: //ssrc_1
 266                 return 4;
 267               case 2: //sdst
 268                 return 4;
 269               default:
 270                 fatal("op idx %i out of bounds\n", opIdx);
 271                 return -1;
 272             }
 273         } // getOperandSize
 274
 275         bool
 276         isSrcOperand(int opIdx) override
 277         {
 278             switch (opIdx) {
 279               case 0: //ssrc_0
 280                 return true;
 281               case 1: //ssrc_1
 282                 return true;
 283               case 2: //sdst
 284                 return false;
 285               default:
 286                 fatal("op idx %i out of bounds\n", opIdx);
 287                 return false;
 288             }
 289         } // isSrcOperand
 290
 291         bool
 292         isDstOperand(int opIdx) override
 293         {
 294             switch (opIdx) {
 295               case 0: //ssrc_0
 296                 return false;
 297               case 1: //ssrc_1
 298                 return false;
 299               case 2: //sdst
 300                 return true;
 301               default:
 302                 fatal("op idx %i out of bounds\n", opIdx);
 303                 return false;
 304             }
 305         } // isDstOperand
 306
 307         void execute(GPUDynInstPtr) override;
 308     }; // Inst_SOP2__S_SUB_I32
 309
 310     class Inst_SOP2__S_ADDC_U32 : public Inst_SOP2
 311     {
 312       public:
 313         Inst_SOP2__S_ADDC_U32(InFmt_SOP2*);
 314         ~Inst_SOP2__S_ADDC_U32();
 315
 316         int
 317         getNumOperands() override
 318         {
 319             return numDstRegOperands() + numSrcRegOperands();
 320         } // getNumOperands
 321
 322         int numDstRegOperands() override { return 1; }
 323         int numSrcRegOperands() override { return 2; }
 324
 325         int
 326         getOperandSize(int opIdx) override
 327         {
 328             switch (opIdx) {
 329               case 0: //ssrc_0
 330                 return 4;
 331               case 1: //ssrc_1
 332                 return 4;
 333               case 2: //sdst
 334                 return 4;
 335               default:
 336                 fatal("op idx %i out of bounds\n", opIdx);
 337                 return -1;
 338             }
 339         } // getOperandSize
 340
 341         bool
 342         isSrcOperand(int opIdx) override
 343         {
 344             switch (opIdx) {
 345               case 0: //ssrc_0
 346                 return true;
 347               case 1: //ssrc_1
 348                 return true;
 349               case 2: //sdst
 350                 return false;
 351               default:
 352                 fatal("op idx %i out of bounds\n", opIdx);
 353                 return false;
 354             }
 355         } // isSrcOperand
 356
 357         bool
 358         isDstOperand(int opIdx) override
 359         {
 360             switch (opIdx) {
 361               case 0: //ssrc_0
 362                 return false;
 363               case 1: //ssrc_1
 364                 return false;
 365               case 2: //sdst
 366                 return true;
 367               default:
 368                 fatal("op idx %i out of bounds\n", opIdx);
 369                 return false;
 370             }
 371         } // isDstOperand
 372
 373         void execute(GPUDynInstPtr) override;
 374     }; // Inst_SOP2__S_ADDC_U32
 375
 376     class Inst_SOP2__S_SUBB_U32 : public Inst_SOP2
 377     {
 378       public:
 379         Inst_SOP2__S_SUBB_U32(InFmt_SOP2*);
 380         ~Inst_SOP2__S_SUBB_U32();
 381
 382         int
 383         getNumOperands() override
 384         {
 385             return numDstRegOperands() + numSrcRegOperands();
 386         } // getNumOperands
 387
 388         int numDstRegOperands() override { return 1; }
 389         int numSrcRegOperands() override { return 2; }
 390
 391         int
 392         getOperandSize(int opIdx) override
 393         {
 394             switch (opIdx) {
 395               case 0: //ssrc_0
 396                 return 4;
 397               case 1: //ssrc_1
 398                 return 4;
 399               case 2: //sdst
 400                 return 4;
 401               default:
 402                 fatal("op idx %i out of bounds\n", opIdx);
 403                 return -1;
 404             }
 405         } // getOperandSize
 406
 407         bool
 408         isSrcOperand(int opIdx) override
 409         {
 410             switch (opIdx) {
 411               case 0: //ssrc_0
 412                 return true;
 413               case 1: //ssrc_1
 414                 return true;
 415               case 2: //sdst
 416                 return false;
 417               default:
 418                 fatal("op idx %i out of bounds\n", opIdx);
 419                 return false;
 420             }
 421         } // isSrcOperand
 422
 423         bool
 424         isDstOperand(int opIdx) override
 425         {
 426             switch (opIdx) {
 427               case 0: //ssrc_0
 428                 return false;
 429               case 1: //ssrc_1
 430                 return false;
 431               case 2: //sdst
 432                 return true;
 433               default:
 434                 fatal("op idx %i out of bounds\n", opIdx);
 435                 return false;
 436             }
 437         } // isDstOperand
 438
 439         void execute(GPUDynInstPtr) override;
 440     }; // Inst_SOP2__S_SUBB_U32
 441
 442     class Inst_SOP2__S_MIN_I32 : public Inst_SOP2
 443     {
 444       public:
 445         Inst_SOP2__S_MIN_I32(InFmt_SOP2*);
 446         ~Inst_SOP2__S_MIN_I32();
 447
 448         int
 449         getNumOperands() override
 450         {
 451             return numDstRegOperands() + numSrcRegOperands();
 452         } // getNumOperands
 453
 454         int numDstRegOperands() override { return 1; }
 455         int numSrcRegOperands() override { return 2; }
 456
 457         int
 458         getOperandSize(int opIdx) override
 459         {
 460             switch (opIdx) {
 461               case 0: //ssrc_0
 462                 return 4;
 463               case 1: //ssrc_1
 464                 return 4;
 465               case 2: //sdst
 466                 return 4;
 467               default:
 468                 fatal("op idx %i out of bounds\n", opIdx);
 469                 return -1;
 470             }
 471         } // getOperandSize
 472
 473         bool
 474         isSrcOperand(int opIdx) override
 475         {
 476             switch (opIdx) {
 477               case 0: //ssrc_0
 478                 return true;
 479               case 1: //ssrc_1
 480                 return true;
 481               case 2: //sdst
 482                 return false;
 483               default:
 484                 fatal("op idx %i out of bounds\n", opIdx);
 485                 return false;
 486             }
 487         } // isSrcOperand
 488
 489         bool
 490         isDstOperand(int opIdx) override
 491         {
 492             switch (opIdx) {
 493               case 0: //ssrc_0
 494                 return false;
 495               case 1: //ssrc_1
 496                 return false;
 497               case 2: //sdst
 498                 return true;
 499               default:
 500                 fatal("op idx %i out of bounds\n", opIdx);
 501                 return false;
 502             }
 503         } // isDstOperand
 504
 505         void execute(GPUDynInstPtr) override;
 506     }; // Inst_SOP2__S_MIN_I32
 507
 508     class Inst_SOP2__S_MIN_U32 : public Inst_SOP2
 509     {
 510       public:
 511         Inst_SOP2__S_MIN_U32(InFmt_SOP2*);
 512         ~Inst_SOP2__S_MIN_U32();
 513
 514         int
 515         getNumOperands() override
 516         {
 517             return numDstRegOperands() + numSrcRegOperands();
 518         } // getNumOperands
 519
 520         int numDstRegOperands() override { return 1; }
 521         int numSrcRegOperands() override { return 2; }
 522
 523         int
 524         getOperandSize(int opIdx) override
 525         {
 526             switch (opIdx) {
 527               case 0: //ssrc_0
 528                 return 4;
 529               case 1: //ssrc_1
 530                 return 4;
 531               case 2: //sdst
 532                 return 4;
 533               default:
 534                 fatal("op idx %i out of bounds\n", opIdx);
 535                 return -1;
 536             }
 537         } // getOperandSize
 538
 539         bool
 540         isSrcOperand(int opIdx) override
 541         {
 542             switch (opIdx) {
 543               case 0: //ssrc_0
 544                 return true;
 545               case 1: //ssrc_1
 546                 return true;
 547               case 2: //sdst
 548                 return false;
 549               default:
 550                 fatal("op idx %i out of bounds\n", opIdx);
 551                 return false;
 552             }
 553         } // isSrcOperand
 554
 555         bool
 556         isDstOperand(int opIdx) override
 557         {
 558             switch (opIdx) {
 559               case 0: //ssrc_0
 560                 return false;
 561               case 1: //ssrc_1
 562                 return false;
 563               case 2: //sdst
 564                 return true;
 565               default:
 566                 fatal("op idx %i out of bounds\n", opIdx);
 567                 return false;
 568             }
 569         } // isDstOperand
 570
 571         void execute(GPUDynInstPtr) override;
 572     }; // Inst_SOP2__S_MIN_U32
 573
 574     class Inst_SOP2__S_MAX_I32 : public Inst_SOP2
 575     {
 576       public:
 577         Inst_SOP2__S_MAX_I32(InFmt_SOP2*);
 578         ~Inst_SOP2__S_MAX_I32();
 579
 580         int
 581         getNumOperands() override
 582         {
 583             return numDstRegOperands() + numSrcRegOperands();
 584         } // getNumOperands
 585
 586         int numDstRegOperands() override { return 1; }
 587         int numSrcRegOperands() override { return 2; }
 588
 589         int
 590         getOperandSize(int opIdx) override
 591         {
 592             switch (opIdx) {
 593               case 0: //ssrc_0
 594                 return 4;
 595               case 1: //ssrc_1
 596                 return 4;
 597               case 2: //sdst
 598                 return 4;
 599               default:
 600                 fatal("op idx %i out of bounds\n", opIdx);
 601                 return -1;
 602             }
 603         } // getOperandSize
 604
 605         bool
 606         isSrcOperand(int opIdx) override
 607         {
 608             switch (opIdx) {
 609               case 0: //ssrc_0
 610                 return true;
 611               case 1: //ssrc_1
 612                 return true;
 613               case 2: //sdst
 614                 return false;
 615               default:
 616                 fatal("op idx %i out of bounds\n", opIdx);
 617                 return false;
 618             }
 619         } // isSrcOperand
 620
 621         bool
 622         isDstOperand(int opIdx) override
 623         {
 624             switch (opIdx) {
 625               case 0: //ssrc_0
 626                 return false;
 627               case 1: //ssrc_1
 628                 return false;
 629               case 2: //sdst
 630                 return true;
 631               default:
 632                 fatal("op idx %i out of bounds\n", opIdx);
 633                 return false;
 634             }
 635         } // isDstOperand
 636
 637         void execute(GPUDynInstPtr) override;
 638     }; // Inst_SOP2__S_MAX_I32
 639
 640     class Inst_SOP2__S_MAX_U32 : public Inst_SOP2
 641     {
 642       public:
 643         Inst_SOP2__S_MAX_U32(InFmt_SOP2*);
 644         ~Inst_SOP2__S_MAX_U32();
 645
 646         int
 647         getNumOperands() override
 648         {
 649             return numDstRegOperands() + numSrcRegOperands();
 650         } // getNumOperands
 651
 652         int numDstRegOperands() override { return 1; }
 653         int numSrcRegOperands() override { return 2; }
 654
 655         int
 656         getOperandSize(int opIdx) override
 657         {
 658             switch (opIdx) {
 659               case 0: //ssrc_0
 660                 return 4;
 661               case 1: //ssrc_1
 662                 return 4;
 663               case 2: //sdst
 664                 return 4;
 665               default:
 666                 fatal("op idx %i out of bounds\n", opIdx);
 667                 return -1;
 668             }
 669         } // getOperandSize
 670
 671         bool
 672         isSrcOperand(int opIdx) override
 673         {
 674             switch (opIdx) {
 675               case 0: //ssrc_0
 676                 return true;
 677               case 1: //ssrc_1
 678                 return true;
 679               case 2: //sdst
 680                 return false;
 681               default:
 682                 fatal("op idx %i out of bounds\n", opIdx);
 683                 return false;
 684             }
 685         } // isSrcOperand
 686
 687         bool
 688         isDstOperand(int opIdx) override
 689         {
 690             switch (opIdx) {
 691               case 0: //ssrc_0
 692                 return false;
 693               case 1: //ssrc_1
 694                 return false;
 695               case 2: //sdst
 696                 return true;
 697               default:
 698                 fatal("op idx %i out of bounds\n", opIdx);
 699                 return false;
 700             }
 701         } // isDstOperand
 702
 703         void execute(GPUDynInstPtr) override;
 704     }; // Inst_SOP2__S_MAX_U32
 705
 706     class Inst_SOP2__S_CSELECT_B32 : public Inst_SOP2
 707     {
 708       public:
 709         Inst_SOP2__S_CSELECT_B32(InFmt_SOP2*);
 710         ~Inst_SOP2__S_CSELECT_B32();
 711
 712         int
 713         getNumOperands() override
 714         {
 715             return numDstRegOperands() + numSrcRegOperands();
 716         } // getNumOperands
 717
 718         int numDstRegOperands() override { return 1; }
 719         int numSrcRegOperands() override { return 2; }
 720
 721         int
 722         getOperandSize(int opIdx) override
 723         {
 724             switch (opIdx) {
 725               case 0: //ssrc_0
 726                 return 4;
 727               case 1: //ssrc_1
 728                 return 4;
 729               case 2: //sdst
 730                 return 4;
 731               default:
 732                 fatal("op idx %i out of bounds\n", opIdx);
 733                 return -1;
 734             }
 735         } // getOperandSize
 736
 737         bool
 738         isSrcOperand(int opIdx) override
 739         {
 740             switch (opIdx) {
 741               case 0: //ssrc_0
 742                 return true;
 743               case 1: //ssrc_1
 744                 return true;
 745               case 2: //sdst
 746                 return false;
 747               default:
 748                 fatal("op idx %i out of bounds\n", opIdx);
 749                 return false;
 750             }
 751         } // isSrcOperand
 752
 753         bool
 754         isDstOperand(int opIdx) override
 755         {
 756             switch (opIdx) {
 757               case 0: //ssrc_0
 758                 return false;
 759               case 1: //ssrc_1
 760                 return false;
 761               case 2: //sdst
 762                 return true;
 763               default:
 764                 fatal("op idx %i out of bounds\n", opIdx);
 765                 return false;
 766             }
 767         } // isDstOperand
 768
 769         void execute(GPUDynInstPtr) override;
 770     }; // Inst_SOP2__S_CSELECT_B32
 771
 772     class Inst_SOP2__S_CSELECT_B64 : public Inst_SOP2
 773     {
 774       public:
 775         Inst_SOP2__S_CSELECT_B64(InFmt_SOP2*);
 776         ~Inst_SOP2__S_CSELECT_B64();
 777
 778         int
 779         getNumOperands() override
 780         {
 781             return numDstRegOperands() + numSrcRegOperands();
 782         } // getNumOperands
 783
 784         int numDstRegOperands() override { return 1; }
 785         int numSrcRegOperands() override { return 2; }
 786
 787         int
 788         getOperandSize(int opIdx) override
 789         {
 790             switch (opIdx) {
 791               case 0: //ssrc_0
 792                 return 8;
 793               case 1: //ssrc_1
 794                 return 8;
 795               case 2: //sdst
 796                 return 8;
 797               default:
 798                 fatal("op idx %i out of bounds\n", opIdx);
 799                 return -1;
 800             }
 801         } // getOperandSize
 802
 803         bool
 804         isSrcOperand(int opIdx) override
 805         {
 806             switch (opIdx) {
 807               case 0: //ssrc_0
 808                 return true;
 809               case 1: //ssrc_1
 810                 return true;
 811               case 2: //sdst
 812                 return false;
 813               default:
 814                 fatal("op idx %i out of bounds\n", opIdx);
 815                 return false;
 816             }
 817         } // isSrcOperand
 818
 819         bool
 820         isDstOperand(int opIdx) override
 821         {
 822             switch (opIdx) {
 823               case 0: //ssrc_0
 824                 return false;
 825               case 1: //ssrc_1
 826                 return false;
 827               case 2: //sdst
 828                 return true;
 829               default:
 830                 fatal("op idx %i out of bounds\n", opIdx);
 831                 return false;
 832             }
 833         } // isDstOperand
 834
 835         void execute(GPUDynInstPtr) override;
 836     }; // Inst_SOP2__S_CSELECT_B64
 837
 838     class Inst_SOP2__S_AND_B32 : public Inst_SOP2
 839     {
 840       public:
 841         Inst_SOP2__S_AND_B32(InFmt_SOP2*);
 842         ~Inst_SOP2__S_AND_B32();
 843
 844         int
 845         getNumOperands() override
 846         {
 847             return numDstRegOperands() + numSrcRegOperands();
 848         } // getNumOperands
 849
 850         int numDstRegOperands() override { return 1; }
 851         int numSrcRegOperands() override { return 2; }
 852
 853         int
 854         getOperandSize(int opIdx) override
 855         {
 856             switch (opIdx) {
 857               case 0: //ssrc_0
 858                 return 4;
 859               case 1: //ssrc_1
 860                 return 4;
 861               case 2: //sdst
 862                 return 4;
 863               default:
 864                 fatal("op idx %i out of bounds\n", opIdx);
 865                 return -1;
 866             }
 867         } // getOperandSize
 868
 869         bool
 870         isSrcOperand(int opIdx) override
 871         {
 872             switch (opIdx) {
 873               case 0: //ssrc_0
 874                 return true;
 875               case 1: //ssrc_1
 876                 return true;
 877               case 2: //sdst
 878                 return false;
 879               default:
 880                 fatal("op idx %i out of bounds\n", opIdx);
 881                 return false;
 882             }
 883         } // isSrcOperand
 884
 885         bool
 886         isDstOperand(int opIdx) override
 887         {
 888             switch (opIdx) {
 889               case 0: //ssrc_0
 890                 return false;
 891               case 1: //ssrc_1
 892                 return false;
 893               case 2: //sdst
 894                 return true;
 895               default:
 896                 fatal("op idx %i out of bounds\n", opIdx);
 897                 return false;
 898             }
 899         } // isDstOperand
 900
 901         void execute(GPUDynInstPtr) override;
 902     }; // Inst_SOP2__S_AND_B32
 903
 904     class Inst_SOP2__S_AND_B64 : public Inst_SOP2
 905     {
 906       public:
 907         Inst_SOP2__S_AND_B64(InFmt_SOP2*);
 908         ~Inst_SOP2__S_AND_B64();
 909
 910         int
 911         getNumOperands() override
 912         {
 913             return numDstRegOperands() + numSrcRegOperands();
 914         } // getNumOperands
 915
 916         int numDstRegOperands() override { return 1; }
 917         int numSrcRegOperands() override { return 2; }
 918
 919         int
 920         getOperandSize(int opIdx) override
 921         {
 922             switch (opIdx) {
 923               case 0: //ssrc_0
 924                 return 8;
 925               case 1: //ssrc_1
 926                 return 8;
 927               case 2: //sdst
 928                 return 8;
 929               default:
 930                 fatal("op idx %i out of bounds\n", opIdx);
 931                 return -1;
 932             }
 933         } // getOperandSize
 934
 935         bool
 936         isSrcOperand(int opIdx) override
 937         {
 938             switch (opIdx) {
 939               case 0: //ssrc_0
 940                 return true;
 941               case 1: //ssrc_1
 942                 return true;
 943               case 2: //sdst
 944                 return false;
 945               default:
 946                 fatal("op idx %i out of bounds\n", opIdx);
 947                 return false;
 948             }
 949         } // isSrcOperand
 950
 951         bool
 952         isDstOperand(int opIdx) override
 953         {
 954             switch (opIdx) {
 955               case 0: //ssrc_0
 956                 return false;
 957               case 1: //ssrc_1
 958                 return false;
 959               case 2: //sdst
 960                 return true;
 961               default:
 962                 fatal("op idx %i out of bounds\n", opIdx);
 963                 return false;
 964             }
 965         } // isDstOperand
 966
 967         void execute(GPUDynInstPtr) override;
 968     }; // Inst_SOP2__S_AND_B64
 969
 970     class Inst_SOP2__S_OR_B32 : public Inst_SOP2
 971     {
 972       public:
 973         Inst_SOP2__S_OR_B32(InFmt_SOP2*);
 974         ~Inst_SOP2__S_OR_B32();
 975
 976         int
 977         getNumOperands() override
 978         {
 979             return numDstRegOperands() + numSrcRegOperands();
 980         } // getNumOperands
 981
 982         int numDstRegOperands() override { return 1; }
 983         int numSrcRegOperands() override { return 2; }
 984
 985         int
 986         getOperandSize(int opIdx) override
 987         {
 988             switch (opIdx) {
 989               case 0: //ssrc_0
 990                 return 4;
 991               case 1: //ssrc_1
 992                 return 4;
 993               case 2: //sdst
 994                 return 4;
 995               default:
 996                 fatal("op idx %i out of bounds\n", opIdx);
 997                 return -1;
 998             }
 999         } // getOperandSize
1000
1001         bool
1002         isSrcOperand(int opIdx) override
1003         {
1004             switch (opIdx) {
1005               case 0: //ssrc_0
1006                 return true;
1007               case 1: //ssrc_1
1008                 return true;
1009               case 2: //sdst
1010                 return false;
1011               default:
1012                 fatal("op idx %i out of bounds\n", opIdx);
1013                 return false;
1014             }
1015         } // isSrcOperand
1016
1017         bool
1018         isDstOperand(int opIdx) override
1019         {
1020             switch (opIdx) {
1021               case 0: //ssrc_0
1022                 return false;
1023               case 1: //ssrc_1
1024                 return false;
1025               case 2: //sdst
1026                 return true;
1027               default:
1028                 fatal("op idx %i out of bounds\n", opIdx);
1029                 return false;
1030             }
1031         } // isDstOperand
1032
1033         void execute(GPUDynInstPtr) override;
1034     }; // Inst_SOP2__S_OR_B32
1035
1036     class Inst_SOP2__S_OR_B64 : public Inst_SOP2
1037     {
1038       public:
1039         Inst_SOP2__S_OR_B64(InFmt_SOP2*);
1040         ~Inst_SOP2__S_OR_B64();
1041
1042         int
1043         getNumOperands() override
1044         {
1045             return numDstRegOperands() + numSrcRegOperands();
1046         } // getNumOperands
1047
1048         int numDstRegOperands() override { return 1; }
1049         int numSrcRegOperands() override { return 2; }
1050
1051         int
1052         getOperandSize(int opIdx) override
1053         {
1054             switch (opIdx) {
1055               case 0: //ssrc_0
1056                 return 8;
1057               case 1: //ssrc_1
1058                 return 8;
1059               case 2: //sdst
1060                 return 8;
1061               default:
1062                 fatal("op idx %i out of bounds\n", opIdx);
1063                 return -1;
1064             }
1065         } // getOperandSize
1066
1067         bool
1068         isSrcOperand(int opIdx) override
1069         {
1070             switch (opIdx) {
1071               case 0: //ssrc_0
1072                 return true;
1073               case 1: //ssrc_1
1074                 return true;
1075               case 2: //sdst
1076                 return false;
1077               default:
1078                 fatal("op idx %i out of bounds\n", opIdx);
1079                 return false;
1080             }
1081         } // isSrcOperand
1082
1083         bool
1084         isDstOperand(int opIdx) override
1085         {
1086             switch (opIdx) {
1087               case 0: //ssrc_0
1088                 return false;
1089               case 1: //ssrc_1
1090                 return false;
1091               case 2: //sdst
1092                 return true;
1093               default:
1094                 fatal("op idx %i out of bounds\n", opIdx);
1095                 return false;
1096             }
1097         } // isDstOperand
1098
1099         void execute(GPUDynInstPtr) override;
1100     }; // Inst_SOP2__S_OR_B64
1101
1102     class Inst_SOP2__S_XOR_B32 : public Inst_SOP2
1103     {
1104       public:
1105         Inst_SOP2__S_XOR_B32(InFmt_SOP2*);
1106         ~Inst_SOP2__S_XOR_B32();
1107
1108         int
1109         getNumOperands() override
1110         {
1111             return numDstRegOperands() + numSrcRegOperands();
1112         } // getNumOperands
1113
1114         int numDstRegOperands() override { return 1; }
1115         int numSrcRegOperands() override { return 2; }
1116
1117         int
1118         getOperandSize(int opIdx) override
1119         {
1120             switch (opIdx) {
1121               case 0: //ssrc_0
1122                 return 4;
1123               case 1: //ssrc_1
1124                 return 4;
1125               case 2: //sdst
1126                 return 4;
1127               default:
1128                 fatal("op idx %i out of bounds\n", opIdx);
1129                 return -1;
1130             }
1131         } // getOperandSize
1132
1133         bool
1134         isSrcOperand(int opIdx) override
1135         {
1136             switch (opIdx) {
1137               case 0: //ssrc_0
1138                 return true;
1139               case 1: //ssrc_1
1140                 return true;
1141               case 2: //sdst
1142                 return false;
1143               default:
1144                 fatal("op idx %i out of bounds\n", opIdx);
1145                 return false;
1146             }
1147         } // isSrcOperand
1148
1149         bool
1150         isDstOperand(int opIdx) override
1151         {
1152             switch (opIdx) {
1153               case 0: //ssrc_0
1154                 return false;
1155               case 1: //ssrc_1
1156                 return false;
1157               case 2: //sdst
1158                 return true;
1159               default:
1160                 fatal("op idx %i out of bounds\n", opIdx);
1161                 return false;
1162             }
1163         } // isDstOperand
1164
1165         void execute(GPUDynInstPtr) override;
1166     }; // Inst_SOP2__S_XOR_B32
1167
1168     class Inst_SOP2__S_XOR_B64 : public Inst_SOP2
1169     {
1170       public:
1171         Inst_SOP2__S_XOR_B64(InFmt_SOP2*);
1172         ~Inst_SOP2__S_XOR_B64();
1173
1174         int
1175         getNumOperands() override
1176         {
1177             return numDstRegOperands() + numSrcRegOperands();
1178         } // getNumOperands
1179
1180         int numDstRegOperands() override { return 1; }
1181         int numSrcRegOperands() override { return 2; }
1182
1183         int
1184         getOperandSize(int opIdx) override
1185         {
1186             switch (opIdx) {
1187               case 0: //ssrc_0
1188                 return 8;
1189               case 1: //ssrc_1
1190                 return 8;
1191               case 2: //sdst
1192                 return 8;
1193               default:
1194                 fatal("op idx %i out of bounds\n", opIdx);
1195                 return -1;
1196             }
1197         } // getOperandSize
1198
1199         bool
1200         isSrcOperand(int opIdx) override
1201         {
1202             switch (opIdx) {
1203               case 0: //ssrc_0
1204                 return true;
1205               case 1: //ssrc_1
1206                 return true;
1207               case 2: //sdst
1208                 return false;
1209               default:
1210                 fatal("op idx %i out of bounds\n", opIdx);
1211                 return false;
1212             }
1213         } // isSrcOperand
1214
1215         bool
1216         isDstOperand(int opIdx) override
1217         {
1218             switch (opIdx) {
1219               case 0: //ssrc_0
1220                 return false;
1221               case 1: //ssrc_1
1222                 return false;
1223               case 2: //sdst
1224                 return true;
1225               default:
1226                 fatal("op idx %i out of bounds\n", opIdx);
1227                 return false;
1228             }
1229         } // isDstOperand
1230
1231         void execute(GPUDynInstPtr) override;
1232     }; // Inst_SOP2__S_XOR_B64
1233
1234     class Inst_SOP2__S_ANDN2_B32 : public Inst_SOP2
1235     {
1236       public:
1237         Inst_SOP2__S_ANDN2_B32(InFmt_SOP2*);
1238         ~Inst_SOP2__S_ANDN2_B32();
1239
1240         int
1241         getNumOperands() override
1242         {
1243             return numDstRegOperands() + numSrcRegOperands();
1244         } // getNumOperands
1245
1246         int numDstRegOperands() override { return 1; }
1247         int numSrcRegOperands() override { return 2; }
1248
1249         int
1250         getOperandSize(int opIdx) override
1251         {
1252             switch (opIdx) {
1253               case 0: //ssrc_0
1254                 return 4;
1255               case 1: //ssrc_1
1256                 return 4;
1257               case 2: //sdst
1258                 return 4;
1259               default:
1260                 fatal("op idx %i out of bounds\n", opIdx);
1261                 return -1;
1262             }
1263         } // getOperandSize
1264
1265         bool
1266         isSrcOperand(int opIdx) override
1267         {
1268             switch (opIdx) {
1269               case 0: //ssrc_0
1270                 return true;
1271               case 1: //ssrc_1
1272                 return true;
1273               case 2: //sdst
1274                 return false;
1275               default:
1276                 fatal("op idx %i out of bounds\n", opIdx);
1277                 return false;
1278             }
1279         } // isSrcOperand
1280
1281         bool
1282         isDstOperand(int opIdx) override
1283         {
1284             switch (opIdx) {
1285               case 0: //ssrc_0
1286                 return false;
1287               case 1: //ssrc_1
1288                 return false;
1289               case 2: //sdst
1290                 return true;
1291               default:
1292                 fatal("op idx %i out of bounds\n", opIdx);
1293                 return false;
1294             }
1295         } // isDstOperand
1296
1297         void execute(GPUDynInstPtr) override;
1298     }; // Inst_SOP2__S_ANDN2_B32
1299
1300     class Inst_SOP2__S_ANDN2_B64 : public Inst_SOP2
1301     {
1302       public:
1303         Inst_SOP2__S_ANDN2_B64(InFmt_SOP2*);
1304         ~Inst_SOP2__S_ANDN2_B64();
1305
1306         int
1307         getNumOperands() override
1308         {
1309             return numDstRegOperands() + numSrcRegOperands();
1310         } // getNumOperands
1311
1312         int numDstRegOperands() override { return 1; }
1313         int numSrcRegOperands() override { return 2; }
1314
1315         int
1316         getOperandSize(int opIdx) override
1317         {
1318             switch (opIdx) {
1319               case 0: //ssrc_0
1320                 return 8;
1321               case 1: //ssrc_1
1322                 return 8;
1323               case 2: //sdst
1324                 return 8;
1325               default:
1326                 fatal("op idx %i out of bounds\n", opIdx);
1327                 return -1;
1328             }
1329         } // getOperandSize
1330
1331         bool
1332         isSrcOperand(int opIdx) override
1333         {
1334             switch (opIdx) {
1335               case 0: //ssrc_0
1336                 return true;
1337               case 1: //ssrc_1
1338                 return true;
1339               case 2: //sdst
1340                 return false;
1341               default:
1342                 fatal("op idx %i out of bounds\n", opIdx);
1343                 return false;
1344             }
1345         } // isSrcOperand
1346
1347         bool
1348         isDstOperand(int opIdx) override
1349         {
1350             switch (opIdx) {
1351               case 0: //ssrc_0
1352                 return false;
1353               case 1: //ssrc_1
1354                 return false;
1355               case 2: //sdst
1356                 return true;
1357               default:
1358                 fatal("op idx %i out of bounds\n", opIdx);
1359                 return false;
1360             }
1361         } // isDstOperand
1362
1363         void execute(GPUDynInstPtr) override;
1364     }; // Inst_SOP2__S_ANDN2_B64
1365
1366     class Inst_SOP2__S_ORN2_B32 : public Inst_SOP2
1367     {
1368       public:
1369         Inst_SOP2__S_ORN2_B32(InFmt_SOP2*);
1370         ~Inst_SOP2__S_ORN2_B32();
1371
1372         int
1373         getNumOperands() override
1374         {
1375             return numDstRegOperands() + numSrcRegOperands();
1376         } // getNumOperands
1377
1378         int numDstRegOperands() override { return 1; }
1379         int numSrcRegOperands() override { return 2; }
1380
1381         int
1382         getOperandSize(int opIdx) override
1383         {
1384             switch (opIdx) {
1385               case 0: //ssrc_0
1386                 return 4;
1387               case 1: //ssrc_1
1388                 return 4;
1389               case 2: //sdst
1390                 return 4;
1391               default:
1392                 fatal("op idx %i out of bounds\n", opIdx);
1393                 return -1;
1394             }
1395         } // getOperandSize
1396
1397         bool
1398         isSrcOperand(int opIdx) override
1399         {
1400             switch (opIdx) {
1401               case 0: //ssrc_0
1402                 return true;
1403               case 1: //ssrc_1
1404                 return true;
1405               case 2: //sdst
1406                 return false;
1407               default:
1408                 fatal("op idx %i out of bounds\n", opIdx);
1409                 return false;
1410             }
1411         } // isSrcOperand
1412
1413         bool
1414         isDstOperand(int opIdx) override
1415         {
1416             switch (opIdx) {
1417               case 0: //ssrc_0
1418                 return false;
1419               case 1: //ssrc_1
1420                 return false;
1421               case 2: //sdst
1422                 return true;
1423               default:
1424                 fatal("op idx %i out of bounds\n", opIdx);
1425                 return false;
1426             }
1427         } // isDstOperand
1428
1429         void execute(GPUDynInstPtr) override;
1430     }; // Inst_SOP2__S_ORN2_B32
1431
1432     class Inst_SOP2__S_ORN2_B64 : public Inst_SOP2
1433     {
1434       public:
1435         Inst_SOP2__S_ORN2_B64(InFmt_SOP2*);
1436         ~Inst_SOP2__S_ORN2_B64();
1437
1438         int
1439         getNumOperands() override
1440         {
1441             return numDstRegOperands() + numSrcRegOperands();
1442         } // getNumOperands
1443
1444         int numDstRegOperands() override { return 1; }
1445         int numSrcRegOperands() override { return 2; }
1446
1447         int
1448         getOperandSize(int opIdx) override
1449         {
1450             switch (opIdx) {
1451               case 0: //ssrc_0
1452                 return 8;
1453               case 1: //ssrc_1
1454                 return 8;
1455               case 2: //sdst
1456                 return 8;
1457               default:
1458                 fatal("op idx %i out of bounds\n", opIdx);
1459                 return -1;
1460             }
1461         } // getOperandSize
1462
1463         bool
1464         isSrcOperand(int opIdx) override
1465         {
1466             switch (opIdx) {
1467               case 0: //ssrc_0
1468                 return true;
1469               case 1: //ssrc_1
1470                 return true;
1471               case 2: //sdst
1472                 return false;
1473               default:
1474                 fatal("op idx %i out of bounds\n", opIdx);
1475                 return false;
1476             }
1477         } // isSrcOperand
1478
1479         bool
1480         isDstOperand(int opIdx) override
1481         {
1482             switch (opIdx) {
1483               case 0: //ssrc_0
1484                 return false;
1485               case 1: //ssrc_1
1486                 return false;
1487               case 2: //sdst
1488                 return true;
1489               default:
1490                 fatal("op idx %i out of bounds\n", opIdx);
1491                 return false;
1492             }
1493         } // isDstOperand
1494
1495         void execute(GPUDynInstPtr) override;
1496     }; // Inst_SOP2__S_ORN2_B64
1497
1498     class Inst_SOP2__S_NAND_B32 : public Inst_SOP2
1499     {
1500       public:
1501         Inst_SOP2__S_NAND_B32(InFmt_SOP2*);
1502         ~Inst_SOP2__S_NAND_B32();
1503
1504         int
1505         getNumOperands() override
1506         {
1507             return numDstRegOperands() + numSrcRegOperands();
1508         } // getNumOperands
1509
1510         int numDstRegOperands() override { return 1; }
1511         int numSrcRegOperands() override { return 2; }
1512
1513         int
1514         getOperandSize(int opIdx) override
1515         {
1516             switch (opIdx) {
1517               case 0: //ssrc_0
1518                 return 4;
1519               case 1: //ssrc_1
1520                 return 4;
1521               case 2: //sdst
1522                 return 4;
1523               default:
1524                 fatal("op idx %i out of bounds\n", opIdx);
1525                 return -1;
1526             }
1527         } // getOperandSize
1528
1529         bool
1530         isSrcOperand(int opIdx) override
1531         {
1532             switch (opIdx) {
1533               case 0: //ssrc_0
1534                 return true;
1535               case 1: //ssrc_1
1536                 return true;
1537               case 2: //sdst
1538                 return false;
1539               default:
1540                 fatal("op idx %i out of bounds\n", opIdx);
1541                 return false;
1542             }
1543         } // isSrcOperand
1544
1545         bool
1546         isDstOperand(int opIdx) override
1547         {
1548             switch (opIdx) {
1549               case 0: //ssrc_0
1550                 return false;
1551               case 1: //ssrc_1
1552                 return false;
1553               case 2: //sdst
1554                 return true;
1555               default:
1556                 fatal("op idx %i out of bounds\n", opIdx);
1557                 return false;
1558             }
1559         } // isDstOperand
1560
1561         void execute(GPUDynInstPtr) override;
1562     }; // Inst_SOP2__S_NAND_B32
1563
1564     class Inst_SOP2__S_NAND_B64 : public Inst_SOP2
1565     {
1566       public:
1567         Inst_SOP2__S_NAND_B64(InFmt_SOP2*);
1568         ~Inst_SOP2__S_NAND_B64();
1569
1570         int
1571         getNumOperands() override
1572         {
1573             return numDstRegOperands() + numSrcRegOperands();
1574         } // getNumOperands
1575
1576         int numDstRegOperands() override { return 1; }
1577         int numSrcRegOperands() override { return 2; }
1578
1579         int
1580         getOperandSize(int opIdx) override
1581         {
1582             switch (opIdx) {
1583               case 0: //ssrc_0
1584                 return 8;
1585               case 1: //ssrc_1
1586                 return 8;
1587               case 2: //sdst
1588                 return 8;
1589               default:
1590                 fatal("op idx %i out of bounds\n", opIdx);
1591                 return -1;
1592             }
1593         } // getOperandSize
1594
1595         bool
1596         isSrcOperand(int opIdx) override
1597         {
1598             switch (opIdx) {
1599               case 0: //ssrc_0
1600                 return true;
1601               case 1: //ssrc_1
1602                 return true;
1603               case 2: //sdst
1604                 return false;
1605               default:
1606                 fatal("op idx %i out of bounds\n", opIdx);
1607                 return false;
1608             }
1609         } // isSrcOperand
1610
1611         bool
1612         isDstOperand(int opIdx) override
1613         {
1614             switch (opIdx) {
1615               case 0: //ssrc_0
1616                 return false;
1617               case 1: //ssrc_1
1618                 return false;
1619               case 2: //sdst
1620                 return true;
1621               default:
1622                 fatal("op idx %i out of bounds\n", opIdx);
1623                 return false;
1624             }
1625         } // isDstOperand
1626
1627         void execute(GPUDynInstPtr) override;
1628     }; // Inst_SOP2__S_NAND_B64
1629
1630     class Inst_SOP2__S_NOR_B32 : public Inst_SOP2
1631     {
1632       public:
1633         Inst_SOP2__S_NOR_B32(InFmt_SOP2*);
1634         ~Inst_SOP2__S_NOR_B32();
1635
1636         int
1637         getNumOperands() override
1638         {
1639             return numDstRegOperands() + numSrcRegOperands();
1640         } // getNumOperands
1641
1642         int numDstRegOperands() override { return 1; }
1643         int numSrcRegOperands() override { return 2; }
1644
1645         int
1646         getOperandSize(int opIdx) override
1647         {
1648             switch (opIdx) {
1649               case 0: //ssrc_0
1650                 return 4;
1651               case 1: //ssrc_1
1652                 return 4;
1653               case 2: //sdst
1654                 return 4;
1655               default:
1656                 fatal("op idx %i out of bounds\n", opIdx);
1657                 return -1;
1658             }
1659         } // getOperandSize
1660
1661         bool
1662         isSrcOperand(int opIdx) override
1663         {
1664             switch (opIdx) {
1665               case 0: //ssrc_0
1666                 return true;
1667               case 1: //ssrc_1
1668                 return true;
1669               case 2: //sdst
1670                 return false;
1671               default:
1672                 fatal("op idx %i out of bounds\n", opIdx);
1673                 return false;
1674             }
1675         } // isSrcOperand
1676
1677         bool
1678         isDstOperand(int opIdx) override
1679         {
1680             switch (opIdx) {
1681               case 0: //ssrc_0
1682                 return false;
1683               case 1: //ssrc_1
1684                 return false;
1685               case 2: //sdst
1686                 return true;
1687               default:
1688                 fatal("op idx %i out of bounds\n", opIdx);
1689                 return false;
1690             }
1691         } // isDstOperand
1692
1693         void execute(GPUDynInstPtr) override;
1694     }; // Inst_SOP2__S_NOR_B32
1695
1696     class Inst_SOP2__S_NOR_B64 : public Inst_SOP2
1697     {
1698       public:
1699         Inst_SOP2__S_NOR_B64(InFmt_SOP2*);
1700         ~Inst_SOP2__S_NOR_B64();
1701
1702         int
1703         getNumOperands() override
1704         {
1705             return numDstRegOperands() + numSrcRegOperands();
1706         } // getNumOperands
1707
1708         int numDstRegOperands() override { return 1; }
1709         int numSrcRegOperands() override { return 2; }
1710
1711         int
1712         getOperandSize(int opIdx) override
1713         {
1714             switch (opIdx) {
1715               case 0: //ssrc_0
1716                 return 8;
1717               case 1: //ssrc_1
1718                 return 8;
1719               case 2: //sdst
1720                 return 8;
1721               default:
1722                 fatal("op idx %i out of bounds\n", opIdx);
1723                 return -1;
1724             }
1725         } // getOperandSize
1726
1727         bool
1728         isSrcOperand(int opIdx) override
1729         {
1730             switch (opIdx) {
1731               case 0: //ssrc_0
1732                 return true;
1733               case 1: //ssrc_1
1734                 return true;
1735               case 2: //sdst
1736                 return false;
1737               default:
1738                 fatal("op idx %i out of bounds\n", opIdx);
1739                 return false;
1740             }
1741         } // isSrcOperand
1742
1743         bool
1744         isDstOperand(int opIdx) override
1745         {
1746             switch (opIdx) {
1747               case 0: //ssrc_0
1748                 return false;
1749               case 1: //ssrc_1
1750                 return false;
1751               case 2: //sdst
1752                 return true;
1753               default:
1754                 fatal("op idx %i out of bounds\n", opIdx);
1755                 return false;
1756             }
1757         } // isDstOperand
1758
1759         void execute(GPUDynInstPtr) override;
1760     }; // Inst_SOP2__S_NOR_B64
1761
1762     class Inst_SOP2__S_XNOR_B32 : public Inst_SOP2
1763     {
1764       public:
1765         Inst_SOP2__S_XNOR_B32(InFmt_SOP2*);
1766         ~Inst_SOP2__S_XNOR_B32();
1767
1768         int
1769         getNumOperands() override
1770         {
1771             return numDstRegOperands() + numSrcRegOperands();
1772         } // getNumOperands
1773
1774         int numDstRegOperands() override { return 1; }
1775         int numSrcRegOperands() override { return 2; }
1776
1777         int
1778         getOperandSize(int opIdx) override
1779         {
1780             switch (opIdx) {
1781               case 0: //ssrc_0
1782                 return 4;
1783               case 1: //ssrc_1
1784                 return 4;
1785               case 2: //sdst
1786                 return 4;
1787               default:
1788                 fatal("op idx %i out of bounds\n", opIdx);
1789                 return -1;
1790             }
1791         } // getOperandSize
1792
1793         bool
1794         isSrcOperand(int opIdx) override
1795         {
1796             switch (opIdx) {
1797               case 0: //ssrc_0
1798                 return true;
1799               case 1: //ssrc_1
1800                 return true;
1801               case 2: //sdst
1802                 return false;
1803               default:
1804                 fatal("op idx %i out of bounds\n", opIdx);
1805                 return false;
1806             }
1807         } // isSrcOperand
1808
1809         bool
1810         isDstOperand(int opIdx) override
1811         {
1812             switch (opIdx) {
1813               case 0: //ssrc_0
1814                 return false;
1815               case 1: //ssrc_1
1816                 return false;
1817               case 2: //sdst
1818                 return true;
1819               default:
1820                 fatal("op idx %i out of bounds\n", opIdx);
1821                 return false;
1822             }
1823         } // isDstOperand
1824
1825         void execute(GPUDynInstPtr) override;
1826     }; // Inst_SOP2__S_XNOR_B32
1827
1828     class Inst_SOP2__S_XNOR_B64 : public Inst_SOP2
1829     {
1830       public:
1831         Inst_SOP2__S_XNOR_B64(InFmt_SOP2*);
1832         ~Inst_SOP2__S_XNOR_B64();
1833
1834         int
1835         getNumOperands() override
1836         {
1837             return numDstRegOperands() + numSrcRegOperands();
1838         } // getNumOperands
1839
1840         int numDstRegOperands() override { return 1; }
1841         int numSrcRegOperands() override { return 2; }
1842
1843         int
1844         getOperandSize(int opIdx) override
1845         {
1846             switch (opIdx) {
1847               case 0: //ssrc_0
1848                 return 8;
1849               case 1: //ssrc_1
1850                 return 8;
1851               case 2: //sdst
1852                 return 8;
1853               default:
1854                 fatal("op idx %i out of bounds\n", opIdx);
1855                 return -1;
1856             }
1857         } // getOperandSize
1858
1859         bool
1860         isSrcOperand(int opIdx) override
1861         {
1862             switch (opIdx) {
1863               case 0: //ssrc_0
1864                 return true;
1865               case 1: //ssrc_1
1866                 return true;
1867               case 2: //sdst
1868                 return false;
1869               default:
1870                 fatal("op idx %i out of bounds\n", opIdx);
1871                 return false;
1872             }
1873         } // isSrcOperand
1874
1875         bool
1876         isDstOperand(int opIdx) override
1877         {
1878             switch (opIdx) {
1879               case 0: //ssrc_0
1880                 return false;
1881               case 1: //ssrc_1
1882                 return false;
1883               case 2: //sdst
1884                 return true;
1885               default:
1886                 fatal("op idx %i out of bounds\n", opIdx);
1887                 return false;
1888             }
1889         } // isDstOperand
1890
1891         void execute(GPUDynInstPtr) override;
1892     }; // Inst_SOP2__S_XNOR_B64
1893
1894     class Inst_SOP2__S_LSHL_B32 : public Inst_SOP2
1895     {
1896       public:
1897         Inst_SOP2__S_LSHL_B32(InFmt_SOP2*);
1898         ~Inst_SOP2__S_LSHL_B32();
1899
1900         int
1901         getNumOperands() override
1902         {
1903             return numDstRegOperands() + numSrcRegOperands();
1904         } // getNumOperands
1905
1906         int numDstRegOperands() override { return 1; }
1907         int numSrcRegOperands() override { return 2; }
1908
1909         int
1910         getOperandSize(int opIdx) override
1911         {
1912             switch (opIdx) {
1913               case 0: //ssrc_0
1914                 return 4;
1915               case 1: //ssrc_1
1916                 return 4;
1917               case 2: //sdst
1918                 return 4;
1919               default:
1920                 fatal("op idx %i out of bounds\n", opIdx);
1921                 return -1;
1922             }
1923         } // getOperandSize
1924
1925         bool
1926         isSrcOperand(int opIdx) override
1927         {
1928             switch (opIdx) {
1929               case 0: //ssrc_0
1930                 return true;
1931               case 1: //ssrc_1
1932                 return true;
1933               case 2: //sdst
1934                 return false;
1935               default:
1936                 fatal("op idx %i out of bounds\n", opIdx);
1937                 return false;
1938             }
1939         } // isSrcOperand
1940
1941         bool
1942         isDstOperand(int opIdx) override
1943         {
1944             switch (opIdx) {
1945               case 0: //ssrc_0
1946                 return false;
1947               case 1: //ssrc_1
1948                 return false;
1949               case 2: //sdst
1950                 return true;
1951               default:
1952                 fatal("op idx %i out of bounds\n", opIdx);
1953                 return false;
1954             }
1955         } // isDstOperand
1956
1957         void execute(GPUDynInstPtr) override;
1958     }; // Inst_SOP2__S_LSHL_B32
1959
1960     class Inst_SOP2__S_LSHL_B64 : public Inst_SOP2
1961     {
1962       public:
1963         Inst_SOP2__S_LSHL_B64(InFmt_SOP2*);
1964         ~Inst_SOP2__S_LSHL_B64();
1965
1966         int
1967         getNumOperands() override
1968         {
1969             return numDstRegOperands() + numSrcRegOperands();
1970         } // getNumOperands
1971
1972         int numDstRegOperands() override { return 1; }
1973         int numSrcRegOperands() override { return 2; }
1974
1975         int
1976         getOperandSize(int opIdx) override
1977         {
1978             switch (opIdx) {
1979               case 0: //ssrc_0
1980                 return 8;
1981               case 1: //ssrc_1
1982                 return 4;
1983               case 2: //sdst
1984                 return 8;
1985               default:
1986                 fatal("op idx %i out of bounds\n", opIdx);
1987                 return -1;
1988             }
1989         } // getOperandSize
1990
1991         bool
1992         isSrcOperand(int opIdx) override
1993         {
1994             switch (opIdx) {
1995               case 0: //ssrc_0
1996                 return true;
1997               case 1: //ssrc_1
1998                 return true;
1999               case 2: //sdst
2000                 return false;
2001               default:
2002                 fatal("op idx %i out of bounds\n", opIdx);
2003                 return false;
2004             }
2005         } // isSrcOperand
2006
2007         bool
2008         isDstOperand(int opIdx) override
2009         {
2010             switch (opIdx) {
2011               case 0: //ssrc_0
2012                 return false;
2013               case 1: //ssrc_1
2014                 return false;
2015               case 2: //sdst
2016                 return true;
2017               default:
2018                 fatal("op idx %i out of bounds\n", opIdx);
2019                 return false;
2020             }
2021         } // isDstOperand
2022
2023         void execute(GPUDynInstPtr) override;
2024     }; // Inst_SOP2__S_LSHL_B64
2025
2026     class Inst_SOP2__S_LSHR_B32 : public Inst_SOP2
2027     {
2028       public:
2029         Inst_SOP2__S_LSHR_B32(InFmt_SOP2*);
2030         ~Inst_SOP2__S_LSHR_B32();
2031
2032         int
2033         getNumOperands() override
2034         {
2035             return numDstRegOperands() + numSrcRegOperands();
2036         } // getNumOperands
2037
2038         int numDstRegOperands() override { return 1; }
2039         int numSrcRegOperands() override { return 2; }
2040
2041         int
2042         getOperandSize(int opIdx) override
2043         {
2044             switch (opIdx) {
2045               case 0: //ssrc_0
2046                 return 4;
2047               case 1: //ssrc_1
2048                 return 4;
2049               case 2: //sdst
2050                 return 4;
2051               default:
2052                 fatal("op idx %i out of bounds\n", opIdx);
2053                 return -1;
2054             }
2055         } // getOperandSize
2056
2057         bool
2058         isSrcOperand(int opIdx) override
2059         {
2060             switch (opIdx) {
2061               case 0: //ssrc_0
2062                 return true;
2063               case 1: //ssrc_1
2064                 return true;
2065               case 2: //sdst
2066                 return false;
2067               default:
2068                 fatal("op idx %i out of bounds\n", opIdx);
2069                 return false;
2070             }
2071         } // isSrcOperand
2072
2073         bool
2074         isDstOperand(int opIdx) override
2075         {
2076             switch (opIdx) {
2077               case 0: //ssrc_0
2078                 return false;
2079               case 1: //ssrc_1
2080                 return false;
2081               case 2: //sdst
2082                 return true;
2083               default:
2084                 fatal("op idx %i out of bounds\n", opIdx);
2085                 return false;
2086             }
2087         } // isDstOperand
2088
2089         void execute(GPUDynInstPtr) override;
2090     }; // Inst_SOP2__S_LSHR_B32
2091
2092     class Inst_SOP2__S_LSHR_B64 : public Inst_SOP2
2093     {
2094       public:
2095         Inst_SOP2__S_LSHR_B64(InFmt_SOP2*);
2096         ~Inst_SOP2__S_LSHR_B64();
2097
2098         int
2099         getNumOperands() override
2100         {
2101             return numDstRegOperands() + numSrcRegOperands();
2102         } // getNumOperands
2103
2104         int numDstRegOperands() override { return 1; }
2105         int numSrcRegOperands() override { return 2; }
2106
2107         int
2108         getOperandSize(int opIdx) override
2109         {
2110             switch (opIdx) {
2111               case 0: //ssrc_0
2112                 return 8;
2113               case 1: //ssrc_1
2114                 return 4;
2115               case 2: //sdst
2116                 return 8;
2117               default:
2118                 fatal("op idx %i out of bounds\n", opIdx);
2119                 return -1;
2120             }
2121         } // getOperandSize
2122
2123         bool
2124         isSrcOperand(int opIdx) override
2125         {
2126             switch (opIdx) {
2127               case 0: //ssrc_0
2128                 return true;
2129               case 1: //ssrc_1
2130                 return true;
2131               case 2: //sdst
2132                 return false;
2133               default:
2134                 fatal("op idx %i out of bounds\n", opIdx);
2135                 return false;
2136             }
2137         } // isSrcOperand
2138
2139         bool
2140         isDstOperand(int opIdx) override
2141         {
2142             switch (opIdx) {
2143               case 0: //ssrc_0
2144                 return false;
2145               case 1: //ssrc_1
2146                 return false;
2147               case 2: //sdst
2148                 return true;
2149               default:
2150                 fatal("op idx %i out of bounds\n", opIdx);
2151                 return false;
2152             }
2153         } // isDstOperand
2154
2155         void execute(GPUDynInstPtr) override;
2156     }; // Inst_SOP2__S_LSHR_B64
2157
2158     class Inst_SOP2__S_ASHR_I32 : public Inst_SOP2
2159     {
2160       public:
2161         Inst_SOP2__S_ASHR_I32(InFmt_SOP2*);
2162         ~Inst_SOP2__S_ASHR_I32();
2163
2164         int
2165         getNumOperands() override
2166         {
2167             return numDstRegOperands() + numSrcRegOperands();
2168         } // getNumOperands
2169
2170         int numDstRegOperands() override { return 1; }
2171         int numSrcRegOperands() override { return 2; }
2172
2173         int
2174         getOperandSize(int opIdx) override
2175         {
2176             switch (opIdx) {
2177               case 0: //ssrc_0
2178                 return 4;
2179               case 1: //ssrc_1
2180                 return 4;
2181               case 2: //sdst
2182                 return 4;
2183               default:
2184                 fatal("op idx %i out of bounds\n", opIdx);
2185                 return -1;
2186             }
2187         } // getOperandSize
2188
2189         bool
2190         isSrcOperand(int opIdx) override
2191         {
2192             switch (opIdx) {
2193               case 0: //ssrc_0
2194                 return true;
2195               case 1: //ssrc_1
2196                 return true;
2197               case 2: //sdst
2198                 return false;
2199               default:
2200                 fatal("op idx %i out of bounds\n", opIdx);
2201                 return false;
2202             }
2203         } // isSrcOperand
2204
2205         bool
2206         isDstOperand(int opIdx) override
2207         {
2208             switch (opIdx) {
2209               case 0: //ssrc_0
2210                 return false;
2211               case 1: //ssrc_1
2212                 return false;
2213               case 2: //sdst
2214                 return true;
2215               default:
2216                 fatal("op idx %i out of bounds\n", opIdx);
2217                 return false;
2218             }
2219         } // isDstOperand
2220
2221         void execute(GPUDynInstPtr) override;
2222     }; // Inst_SOP2__S_ASHR_I32
2223
2224     class Inst_SOP2__S_ASHR_I64 : public Inst_SOP2
2225     {
2226       public:
2227         Inst_SOP2__S_ASHR_I64(InFmt_SOP2*);
2228         ~Inst_SOP2__S_ASHR_I64();
2229
2230         int
2231         getNumOperands() override
2232         {
2233             return numDstRegOperands() + numSrcRegOperands();
2234         } // getNumOperands
2235
2236         int numDstRegOperands() override { return 1; }
2237         int numSrcRegOperands() override { return 2; }
2238
2239         int
2240         getOperandSize(int opIdx) override
2241         {
2242             switch (opIdx) {
2243               case 0: //ssrc_0
2244                 return 8;
2245               case 1: //ssrc_1
2246                 return 4;
2247               case 2: //sdst
2248                 return 8;
2249               default:
2250                 fatal("op idx %i out of bounds\n", opIdx);
2251                 return -1;
2252             }
2253         } // getOperandSize
2254
2255         bool
2256         isSrcOperand(int opIdx) override
2257         {
2258             switch (opIdx) {
2259               case 0: //ssrc_0
2260                 return true;
2261               case 1: //ssrc_1
2262                 return true;
2263               case 2: //sdst
2264                 return false;
2265               default:
2266                 fatal("op idx %i out of bounds\n", opIdx);
2267                 return false;
2268             }
2269         } // isSrcOperand
2270
2271         bool
2272         isDstOperand(int opIdx) override
2273         {
2274             switch (opIdx) {
2275               case 0: //ssrc_0
2276                 return false;
2277               case 1: //ssrc_1
2278                 return false;
2279               case 2: //sdst
2280                 return true;
2281               default:
2282                 fatal("op idx %i out of bounds\n", opIdx);
2283                 return false;
2284             }
2285         } // isDstOperand
2286
2287         void execute(GPUDynInstPtr) override;
2288     }; // Inst_SOP2__S_ASHR_I64
2289
2290     class Inst_SOP2__S_BFM_B32 : public Inst_SOP2
2291     {
2292       public:
2293         Inst_SOP2__S_BFM_B32(InFmt_SOP2*);
2294         ~Inst_SOP2__S_BFM_B32();
2295
2296         int
2297         getNumOperands() override
2298         {
2299             return numDstRegOperands() + numSrcRegOperands();
2300         } // getNumOperands
2301
2302         int numDstRegOperands() override { return 1; }
2303         int numSrcRegOperands() override { return 2; }
2304
2305         int
2306         getOperandSize(int opIdx) override
2307         {
2308             switch (opIdx) {
2309               case 0: //ssrc_0
2310                 return 4;
2311               case 1: //ssrc_1
2312                 return 4;
2313               case 2: //sdst
2314                 return 4;
2315               default:
2316                 fatal("op idx %i out of bounds\n", opIdx);
2317                 return -1;
2318             }
2319         } // getOperandSize
2320
2321         bool
2322         isSrcOperand(int opIdx) override
2323         {
2324             switch (opIdx) {
2325               case 0: //ssrc_0
2326                 return true;
2327               case 1: //ssrc_1
2328                 return true;
2329               case 2: //sdst
2330                 return false;
2331               default:
2332                 fatal("op idx %i out of bounds\n", opIdx);
2333                 return false;
2334             }
2335         } // isSrcOperand
2336
2337         bool
2338         isDstOperand(int opIdx) override
2339         {
2340             switch (opIdx) {
2341               case 0: //ssrc_0
2342                 return false;
2343               case 1: //ssrc_1
2344                 return false;
2345               case 2: //sdst
2346                 return true;
2347               default:
2348                 fatal("op idx %i out of bounds\n", opIdx);
2349                 return false;
2350             }
2351         } // isDstOperand
2352
2353         void execute(GPUDynInstPtr) override;
2354     }; // Inst_SOP2__S_BFM_B32
2355
2356     class Inst_SOP2__S_BFM_B64 : public Inst_SOP2
2357     {
2358       public:
2359         Inst_SOP2__S_BFM_B64(InFmt_SOP2*);
2360         ~Inst_SOP2__S_BFM_B64();
2361
2362         int
2363         getNumOperands() override
2364         {
2365             return numDstRegOperands() + numSrcRegOperands();
2366         } // getNumOperands
2367
2368         int numDstRegOperands() override { return 1; }
2369         int numSrcRegOperands() override { return 2; }
2370
2371         int
2372         getOperandSize(int opIdx) override
2373         {
2374             switch (opIdx) {
2375               case 0: //ssrc_0
2376                 return 4;
2377               case 1: //ssrc_1
2378                 return 4;
2379               case 2: //sdst
2380                 return 8;
2381               default:
2382                 fatal("op idx %i out of bounds\n", opIdx);
2383                 return -1;
2384             }
2385         } // getOperandSize
2386
2387         bool
2388         isSrcOperand(int opIdx) override
2389         {
2390             switch (opIdx) {
2391               case 0: //ssrc_0
2392                 return true;
2393               case 1: //ssrc_1
2394                 return true;
2395               case 2: //sdst
2396                 return false;
2397               default:
2398                 fatal("op idx %i out of bounds\n", opIdx);
2399                 return false;
2400             }
2401         } // isSrcOperand
2402
2403         bool
2404         isDstOperand(int opIdx) override
2405         {
2406             switch (opIdx) {
2407               case 0: //ssrc_0
2408                 return false;
2409               case 1: //ssrc_1
2410                 return false;
2411               case 2: //sdst
2412                 return true;
2413               default:
2414                 fatal("op idx %i out of bounds\n", opIdx);
2415                 return false;
2416             }
2417         } // isDstOperand
2418
2419         void execute(GPUDynInstPtr) override;
2420     }; // Inst_SOP2__S_BFM_B64
2421
2422     class Inst_SOP2__S_MUL_I32 : public Inst_SOP2
2423     {
2424       public:
2425         Inst_SOP2__S_MUL_I32(InFmt_SOP2*);
2426         ~Inst_SOP2__S_MUL_I32();
2427
2428         int
2429         getNumOperands() override
2430         {
2431             return numDstRegOperands() + numSrcRegOperands();
2432         } // getNumOperands
2433
2434         int numDstRegOperands() override { return 1; }
2435         int numSrcRegOperands() override { return 2; }
2436
2437         int
2438         getOperandSize(int opIdx) override
2439         {
2440             switch (opIdx) {
2441               case 0: //ssrc_0
2442                 return 4;
2443               case 1: //ssrc_1
2444                 return 4;
2445               case 2: //sdst
2446                 return 4;
2447               default:
2448                 fatal("op idx %i out of bounds\n", opIdx);
2449                 return -1;
2450             }
2451         } // getOperandSize
2452
2453         bool
2454         isSrcOperand(int opIdx) override
2455         {
2456             switch (opIdx) {
2457               case 0: //ssrc_0
2458                 return true;
2459               case 1: //ssrc_1
2460                 return true;
2461               case 2: //sdst
2462                 return false;
2463               default:
2464                 fatal("op idx %i out of bounds\n", opIdx);
2465                 return false;
2466             }
2467         } // isSrcOperand
2468
2469         bool
2470         isDstOperand(int opIdx) override
2471         {
2472             switch (opIdx) {
2473               case 0: //ssrc_0
2474                 return false;
2475               case 1: //ssrc_1
2476                 return false;
2477               case 2: //sdst
2478                 return true;
2479               default:
2480                 fatal("op idx %i out of bounds\n", opIdx);
2481                 return false;
2482             }
2483         } // isDstOperand
2484
2485         void execute(GPUDynInstPtr) override;
2486     }; // Inst_SOP2__S_MUL_I32
2487
2488     class Inst_SOP2__S_BFE_U32 : public Inst_SOP2
2489     {
2490       public:
2491         Inst_SOP2__S_BFE_U32(InFmt_SOP2*);
2492         ~Inst_SOP2__S_BFE_U32();
2493
2494         int
2495         getNumOperands() override
2496         {
2497             return numDstRegOperands() + numSrcRegOperands();
2498         } // getNumOperands
2499
2500         int numDstRegOperands() override { return 1; }
2501         int numSrcRegOperands() override { return 2; }
2502
2503         int
2504         getOperandSize(int opIdx) override
2505         {
2506             switch (opIdx) {
2507               case 0: //ssrc_0
2508                 return 4;
2509               case 1: //ssrc_1
2510                 return 4;
2511               case 2: //sdst
2512                 return 4;
2513               default:
2514                 fatal("op idx %i out of bounds\n", opIdx);
2515                 return -1;
2516             }
2517         } // getOperandSize
2518
2519         bool
2520         isSrcOperand(int opIdx) override
2521         {
2522             switch (opIdx) {
2523               case 0: //ssrc_0
2524                 return true;
2525               case 1: //ssrc_1
2526                 return true;
2527               case 2: //sdst
2528                 return false;
2529               default:
2530                 fatal("op idx %i out of bounds\n", opIdx);
2531                 return false;
2532             }
2533         } // isSrcOperand
2534
2535         bool
2536         isDstOperand(int opIdx) override
2537         {
2538             switch (opIdx) {
2539               case 0: //ssrc_0
2540                 return false;
2541               case 1: //ssrc_1
2542                 return false;
2543               case 2: //sdst
2544                 return true;
2545               default:
2546                 fatal("op idx %i out of bounds\n", opIdx);
2547                 return false;
2548             }
2549         } // isDstOperand
2550
2551         void execute(GPUDynInstPtr) override;
2552     }; // Inst_SOP2__S_BFE_U32
2553
2554     class Inst_SOP2__S_BFE_I32 : public Inst_SOP2
2555     {
2556       public:
2557         Inst_SOP2__S_BFE_I32(InFmt_SOP2*);
2558         ~Inst_SOP2__S_BFE_I32();
2559
2560         int
2561         getNumOperands() override
2562         {
2563             return numDstRegOperands() + numSrcRegOperands();
2564         } // getNumOperands
2565
2566         int numDstRegOperands() override { return 1; }
2567         int numSrcRegOperands() override { return 2; }
2568
2569         int
2570         getOperandSize(int opIdx) override
2571         {
2572             switch (opIdx) {
2573               case 0: //ssrc_0
2574                 return 4;
2575               case 1: //ssrc_1
2576                 return 4;
2577               case 2: //sdst
2578                 return 4;
2579               default:
2580                 fatal("op idx %i out of bounds\n", opIdx);
2581                 return -1;
2582             }
2583         } // getOperandSize
2584
2585         bool
2586         isSrcOperand(int opIdx) override
2587         {
2588             switch (opIdx) {
2589               case 0: //ssrc_0
2590                 return true;
2591               case 1: //ssrc_1
2592                 return true;
2593               case 2: //sdst
2594                 return false;
2595               default:
2596                 fatal("op idx %i out of bounds\n", opIdx);
2597                 return false;
2598             }
2599         } // isSrcOperand
2600
2601         bool
2602         isDstOperand(int opIdx) override
2603         {
2604             switch (opIdx) {
2605               case 0: //ssrc_0
2606                 return false;
2607               case 1: //ssrc_1
2608                 return false;
2609               case 2: //sdst
2610                 return true;
2611               default:
2612                 fatal("op idx %i out of bounds\n", opIdx);
2613                 return false;
2614             }
2615         } // isDstOperand
2616
2617         void execute(GPUDynInstPtr) override;
2618     }; // Inst_SOP2__S_BFE_I32
2619
2620     class Inst_SOP2__S_BFE_U64 : public Inst_SOP2
2621     {
2622       public:
2623         Inst_SOP2__S_BFE_U64(InFmt_SOP2*);
2624         ~Inst_SOP2__S_BFE_U64();
2625
2626         int
2627         getNumOperands() override
2628         {
2629             return numDstRegOperands() + numSrcRegOperands();
2630         } // getNumOperands
2631
2632         int numDstRegOperands() override { return 1; }
2633         int numSrcRegOperands() override { return 2; }
2634
2635         int
2636         getOperandSize(int opIdx) override
2637         {
2638             switch (opIdx) {
2639               case 0: //ssrc_0
2640                 return 8;
2641               case 1: //ssrc_1
2642                 return 4;
2643               case 2: //sdst
2644                 return 8;
2645               default:
2646                 fatal("op idx %i out of bounds\n", opIdx);
2647                 return -1;
2648             }
2649         } // getOperandSize
2650
2651         bool
2652         isSrcOperand(int opIdx) override
2653         {
2654             switch (opIdx) {
2655               case 0: //ssrc_0
2656                 return true;
2657               case 1: //ssrc_1
2658                 return true;
2659               case 2: //sdst
2660                 return false;
2661               default:
2662                 fatal("op idx %i out of bounds\n", opIdx);
2663                 return false;
2664             }
2665         } // isSrcOperand
2666
2667         bool
2668         isDstOperand(int opIdx) override
2669         {
2670             switch (opIdx) {
2671               case 0: //ssrc_0
2672                 return false;
2673               case 1: //ssrc_1
2674                 return false;
2675               case 2: //sdst
2676                 return true;
2677               default:
2678                 fatal("op idx %i out of bounds\n", opIdx);
2679                 return false;
2680             }
2681         } // isDstOperand
2682
2683         void execute(GPUDynInstPtr) override;
2684     }; // Inst_SOP2__S_BFE_U64
2685
2686     class Inst_SOP2__S_BFE_I64 : public Inst_SOP2
2687     {
2688       public:
2689         Inst_SOP2__S_BFE_I64(InFmt_SOP2*);
2690         ~Inst_SOP2__S_BFE_I64();
2691
2692         int
2693         getNumOperands() override
2694         {
2695             return numDstRegOperands() + numSrcRegOperands();
2696         } // getNumOperands
2697
2698         int numDstRegOperands() override { return 1; }
2699         int numSrcRegOperands() override { return 2; }
2700
2701         int
2702         getOperandSize(int opIdx) override
2703         {
2704             switch (opIdx) {
2705               case 0: //ssrc_0
2706                 return 8;
2707               case 1: //ssrc_1
2708                 return 4;
2709               case 2: //sdst
2710                 return 8;
2711               default:
2712                 fatal("op idx %i out of bounds\n", opIdx);
2713                 return -1;
2714             }
2715         } // getOperandSize
2716
2717         bool
2718         isSrcOperand(int opIdx) override
2719         {
2720             switch (opIdx) {
2721               case 0: //ssrc_0
2722                 return true;
2723               case 1: //ssrc_1
2724                 return true;
2725               case 2: //sdst
2726                 return false;
2727               default:
2728                 fatal("op idx %i out of bounds\n", opIdx);
2729                 return false;
2730             }
2731         } // isSrcOperand
2732
2733         bool
2734         isDstOperand(int opIdx) override
2735         {
2736             switch (opIdx) {
2737               case 0: //ssrc_0
2738                 return false;
2739               case 1: //ssrc_1
2740                 return false;
2741               case 2: //sdst
2742                 return true;
2743               default:
2744                 fatal("op idx %i out of bounds\n", opIdx);
2745                 return false;
2746             }
2747         } // isDstOperand
2748
2749         void execute(GPUDynInstPtr) override;
2750     }; // Inst_SOP2__S_BFE_I64
2751
2752     class Inst_SOP2__S_CBRANCH_G_FORK : public Inst_SOP2
2753     {
2754       public:
2755         Inst_SOP2__S_CBRANCH_G_FORK(InFmt_SOP2*);
2756         ~Inst_SOP2__S_CBRANCH_G_FORK();
2757
2758         int
2759         getNumOperands() override
2760         {
2761             return numDstRegOperands() + numSrcRegOperands();
2762         } // getNumOperands
2763
2764         int numDstRegOperands() override { return 0; }
2765         int numSrcRegOperands() override { return 2; }
2766
2767         int
2768         getOperandSize(int opIdx) override
2769         {
2770             switch (opIdx) {
2771               case 0: //ssrc_0
2772                 return 8;
2773               case 1: //ssrc_1
2774                 return 8;
2775               case 2: //sdst
2776                 return 4;
2777               default:
2778                 fatal("op idx %i out of bounds\n", opIdx);
2779                 return -1;
2780             }
2781         } // getOperandSize
2782
2783         bool
2784         isSrcOperand(int opIdx) override
2785         {
2786             switch (opIdx) {
2787               case 0: //ssrc_0
2788                 return true;
2789               case 1: //ssrc_1
2790                 return true;
2791               case 2: //sdst
2792                 return false;
2793               default:
2794                 fatal("op idx %i out of bounds\n", opIdx);
2795                 return false;
2796             }
2797         } // isSrcOperand
2798
2799         bool
2800         isDstOperand(int opIdx) override
2801         {
2802             switch (opIdx) {
2803               case 0: //ssrc_0
2804                 return false;
2805               case 1: //ssrc_1
2806                 return false;
2807               case 2: //sdst
2808                 return true;
2809               default:
2810                 fatal("op idx %i out of bounds\n", opIdx);
2811                 return false;
2812             }
2813         } // isDstOperand
2814
2815         void execute(GPUDynInstPtr) override;
2816     }; // Inst_SOP2__S_CBRANCH_G_FORK
2817
2818     class Inst_SOP2__S_ABSDIFF_I32 : public Inst_SOP2
2819     {
2820       public:
2821         Inst_SOP2__S_ABSDIFF_I32(InFmt_SOP2*);
2822         ~Inst_SOP2__S_ABSDIFF_I32();
2823
2824         int
2825         getNumOperands() override
2826         {
2827             return numDstRegOperands() + numSrcRegOperands();
2828         } // getNumOperands
2829
2830         int numDstRegOperands() override { return 1; }
2831         int numSrcRegOperands() override { return 2; }
2832
2833         int
2834         getOperandSize(int opIdx) override
2835         {
2836             switch (opIdx) {
2837               case 0: //ssrc_0
2838                 return 4;
2839               case 1: //ssrc_1
2840                 return 4;
2841               case 2: //sdst
2842                 return 4;
2843               default:
2844                 fatal("op idx %i out of bounds\n", opIdx);
2845                 return -1;
2846             }
2847         } // getOperandSize
2848
2849         bool
2850         isSrcOperand(int opIdx) override
2851         {
2852             switch (opIdx) {
2853               case 0: //ssrc_0
2854                 return true;
2855               case 1: //ssrc_1
2856                 return true;
2857               case 2: //sdst
2858                 return false;
2859               default:
2860                 fatal("op idx %i out of bounds\n", opIdx);
2861                 return false;
2862             }
2863         } // isSrcOperand
2864
2865         bool
2866         isDstOperand(int opIdx) override
2867         {
2868             switch (opIdx) {
2869               case 0: //ssrc_0
2870                 return false;
2871               case 1: //ssrc_1
2872                 return false;
2873               case 2: //sdst
2874                 return true;
2875               default:
2876                 fatal("op idx %i out of bounds\n", opIdx);
2877                 return false;
2878             }
2879         } // isDstOperand
2880
2881         void execute(GPUDynInstPtr) override;
2882     }; // Inst_SOP2__S_ABSDIFF_I32
2883
2884     class Inst_SOP2__S_RFE_RESTORE_B64 : public Inst_SOP2
2885     {
2886       public:
2887         Inst_SOP2__S_RFE_RESTORE_B64(InFmt_SOP2*);
2888         ~Inst_SOP2__S_RFE_RESTORE_B64();
2889
2890         int
2891         getNumOperands() override
2892         {
2893             return numDstRegOperands() + numSrcRegOperands();
2894         } // getNumOperands
2895
2896         int numDstRegOperands() override { return 0; }
2897         int numSrcRegOperands() override { return 2; }
2898
2899         int
2900         getOperandSize(int opIdx) override
2901         {
2902             switch (opIdx) {
2903               case 0: //ssrc_0
2904                 return 8;
2905               case 1: //ssrc_1
2906                 return 4;
2907               case 2: //sdst
2908                 return 4;
2909               default:
2910                 fatal("op idx %i out of bounds\n", opIdx);
2911                 return -1;
2912             }
2913         } // getOperandSize
2914
2915         bool
2916         isSrcOperand(int opIdx) override
2917         {
2918             switch (opIdx) {
2919               case 0: //ssrc_0
2920                 return true;
2921               case 1: //ssrc_1
2922                 return true;
2923               case 2: //sdst
2924                 return false;
2925               default:
2926                 fatal("op idx %i out of bounds\n", opIdx);
2927                 return false;
2928             }
2929         } // isSrcOperand
2930
2931         bool
2932         isDstOperand(int opIdx) override
2933         {
2934             switch (opIdx) {
2935               case 0: //ssrc_0
2936                 return false;
2937               case 1: //ssrc_1
2938                 return false;
2939               case 2: //sdst
2940                 return true;
2941               default:
2942                 fatal("op idx %i out of bounds\n", opIdx);
2943                 return false;
2944             }
2945         } // isDstOperand
2946
2947         void execute(GPUDynInstPtr) override;
2948     }; // Inst_SOP2__S_RFE_RESTORE_B64
2949
2950     class Inst_SOPK__S_MOVK_I32 : public Inst_SOPK
2951     {
2952       public:
2953         Inst_SOPK__S_MOVK_I32(InFmt_SOPK*);
2954         ~Inst_SOPK__S_MOVK_I32();
2955
2956         int
2957         getNumOperands() override
2958         {
2959             return numDstRegOperands() + numSrcRegOperands();
2960         } // getNumOperands
2961
2962         int numDstRegOperands() override { return 1; }
2963         int numSrcRegOperands() override { return 1; }
2964
2965         int
2966         getOperandSize(int opIdx) override
2967         {
2968             switch (opIdx) {
2969               case 0: //simm16
2970                 return 2;
2971               case 1: //sdst
2972                 return 4;
2973               default:
2974                 fatal("op idx %i out of bounds\n", opIdx);
2975                 return -1;
2976             }
2977         } // getOperandSize
2978
2979         bool
2980         isSrcOperand(int opIdx) override
2981         {
2982             switch (opIdx) {
2983               case 0: //simm16
2984                 return true;
2985               case 1: //sdst
2986                 return false;
2987               default:
2988                 fatal("op idx %i out of bounds\n", opIdx);
2989                 return false;
2990             }
2991         } // isSrcOperand
2992
2993         bool
2994         isDstOperand(int opIdx) override
2995         {
2996             switch (opIdx) {
2997               case 0: //simm16
2998                 return false;
2999               case 1: //sdst
3000                 return true;
3001               default:
3002                 fatal("op idx %i out of bounds\n", opIdx);
3003                 return false;
3004             }
3005         } // isDstOperand
3006
3007         void execute(GPUDynInstPtr) override;
3008     }; // Inst_SOPK__S_MOVK_I32
3009
3010     class Inst_SOPK__S_CMOVK_I32 : public Inst_SOPK
3011     {
3012       public:
3013         Inst_SOPK__S_CMOVK_I32(InFmt_SOPK*);
3014         ~Inst_SOPK__S_CMOVK_I32();
3015
3016         int
3017         getNumOperands() override
3018         {
3019             return numDstRegOperands() + numSrcRegOperands();
3020         } // getNumOperands
3021
3022         int numDstRegOperands() override { return 1; }
3023         int numSrcRegOperands() override { return 1; }
3024
3025         int
3026         getOperandSize(int opIdx) override
3027         {
3028             switch (opIdx) {
3029               case 0: //simm16
3030                 return 2;
3031               case 1: //sdst
3032                 return 4;
3033               default:
3034                 fatal("op idx %i out of bounds\n", opIdx);
3035                 return -1;
3036             }
3037         } // getOperandSize
3038
3039         bool
3040         isSrcOperand(int opIdx) override
3041         {
3042             switch (opIdx) {
3043               case 0: //simm16
3044                 return true;
3045               case 1: //sdst
3046                 return false;
3047               default:
3048                 fatal("op idx %i out of bounds\n", opIdx);
3049                 return false;
3050             }
3051         } // isSrcOperand
3052
3053         bool
3054         isDstOperand(int opIdx) override
3055         {
3056             switch (opIdx) {
3057               case 0: //simm16
3058                 return false;
3059               case 1: //sdst
3060                 return true;
3061               default:
3062                 fatal("op idx %i out of bounds\n", opIdx);
3063                 return false;
3064             }
3065         } // isDstOperand
3066
3067         void execute(GPUDynInstPtr) override;
3068     }; // Inst_SOPK__S_CMOVK_I32
3069
3070     class Inst_SOPK__S_CMPK_EQ_I32 : public Inst_SOPK
3071     {
3072       public:
3073         Inst_SOPK__S_CMPK_EQ_I32(InFmt_SOPK*);
3074         ~Inst_SOPK__S_CMPK_EQ_I32();
3075
3076         int
3077         getNumOperands() override
3078         {
3079             return numDstRegOperands() + numSrcRegOperands();
3080         } // getNumOperands
3081
3082         int numDstRegOperands() override { return 0; }
3083         int numSrcRegOperands() override { return 2; }
3084
3085         int
3086         getOperandSize(int opIdx) override
3087         {
3088             switch (opIdx) {
3089               case 0: //ssrc
3090                 return 4;
3091               case 1: //simm16
3092                 return 2;
3093               default:
3094                 fatal("op idx %i out of bounds\n", opIdx);
3095                 return -1;
3096             }
3097         } // getOperandSize
3098
3099         bool
3100         isSrcOperand(int opIdx) override
3101         {
3102             switch (opIdx) {
3103               case 0: //ssrc
3104                 return true;
3105               case 1: //simm16
3106                 return true;
3107               default:
3108                 fatal("op idx %i out of bounds\n", opIdx);
3109                 return false;
3110             }
3111         } // isSrcOperand
3112
3113         bool
3114         isDstOperand(int opIdx) override
3115         {
3116             switch (opIdx) {
3117               case 0: //ssrc
3118                 return false;
3119               case 1: //simm16
3120                 return false;
3121               default:
3122                 fatal("op idx %i out of bounds\n", opIdx);
3123                 return false;
3124             }
3125         } // isDstOperand
3126
3127         void execute(GPUDynInstPtr) override;
3128     }; // Inst_SOPK__S_CMPK_EQ_I32
3129
3130     class Inst_SOPK__S_CMPK_LG_I32 : public Inst_SOPK
3131     {
3132       public:
3133         Inst_SOPK__S_CMPK_LG_I32(InFmt_SOPK*);
3134         ~Inst_SOPK__S_CMPK_LG_I32();
3135
3136         int
3137         getNumOperands() override
3138         {
3139             return numDstRegOperands() + numSrcRegOperands();
3140         } // getNumOperands
3141
3142         int numDstRegOperands() override { return 0; }
3143         int numSrcRegOperands() override { return 2; }
3144
3145         int
3146         getOperandSize(int opIdx) override
3147         {
3148             switch (opIdx) {
3149               case 0: //ssrc
3150                 return 4;
3151               case 1: //simm16
3152                 return 2;
3153               default:
3154                 fatal("op idx %i out of bounds\n", opIdx);
3155                 return -1;
3156             }
3157         } // getOperandSize
3158
3159         bool
3160         isSrcOperand(int opIdx) override
3161         {
3162             switch (opIdx) {
3163               case 0: //ssrc
3164                 return true;
3165               case 1: //simm16
3166                 return true;
3167               default:
3168                 fatal("op idx %i out of bounds\n", opIdx);
3169                 return false;
3170             }
3171         } // isSrcOperand
3172
3173         bool
3174         isDstOperand(int opIdx) override
3175         {
3176             switch (opIdx) {
3177               case 0: //ssrc
3178                 return false;
3179               case 1: //simm16
3180                 return false;
3181               default:
3182                 fatal("op idx %i out of bounds\n", opIdx);
3183                 return false;
3184             }
3185         } // isDstOperand
3186
3187         void execute(GPUDynInstPtr) override;
3188     }; // Inst_SOPK__S_CMPK_LG_I32
3189
3190     class Inst_SOPK__S_CMPK_GT_I32 : public Inst_SOPK
3191     {
3192       public:
3193         Inst_SOPK__S_CMPK_GT_I32(InFmt_SOPK*);
3194         ~Inst_SOPK__S_CMPK_GT_I32();
3195
3196         int
3197         getNumOperands() override
3198         {
3199             return numDstRegOperands() + numSrcRegOperands();
3200         } // getNumOperands
3201
3202         int numDstRegOperands() override { return 0; }
3203         int numSrcRegOperands() override { return 2; }
3204
3205         int
3206         getOperandSize(int opIdx) override
3207         {
3208             switch (opIdx) {
3209               case 0: //ssrc
3210                 return 4;
3211               case 1: //simm16
3212                 return 2;
3213               default:
3214                 fatal("op idx %i out of bounds\n", opIdx);
3215                 return -1;
3216             }
3217         } // getOperandSize
3218
3219         bool
3220         isSrcOperand(int opIdx) override
3221         {
3222             switch (opIdx) {
3223               case 0: //ssrc
3224                 return true;
3225               case 1: //simm16
3226                 return true;
3227               default:
3228                 fatal("op idx %i out of bounds\n", opIdx);
3229                 return false;
3230             }
3231         } // isSrcOperand
3232
3233         bool
3234         isDstOperand(int opIdx) override
3235         {
3236             switch (opIdx) {
3237               case 0: //ssrc
3238                 return false;
3239               case 1: //simm16
3240                 return false;
3241               default:
3242                 fatal("op idx %i out of bounds\n", opIdx);
3243                 return false;
3244             }
3245         } // isDstOperand
3246
3247         void execute(GPUDynInstPtr) override;
3248     }; // Inst_SOPK__S_CMPK_GT_I32
3249
3250     class Inst_SOPK__S_CMPK_GE_I32 : public Inst_SOPK
3251     {
3252       public:
3253         Inst_SOPK__S_CMPK_GE_I32(InFmt_SOPK*);
3254         ~Inst_SOPK__S_CMPK_GE_I32();
3255
3256         int
3257         getNumOperands() override
3258         {
3259             return numDstRegOperands() + numSrcRegOperands();
3260         } // getNumOperands
3261
3262         int numDstRegOperands() override { return 0; }
3263         int numSrcRegOperands() override { return 2; }
3264
3265         int
3266         getOperandSize(int opIdx) override
3267         {
3268             switch (opIdx) {
3269               case 0: //ssrc
3270                 return 4;
3271               case 1: //simm16
3272                 return 2;
3273               default:
3274                 fatal("op idx %i out of bounds\n", opIdx);
3275                 return -1;
3276             }
3277         } // getOperandSize
3278
3279         bool
3280         isSrcOperand(int opIdx) override
3281         {
3282             switch (opIdx) {
3283               case 0: //ssrc
3284                 return true;
3285               case 1: //simm16
3286                 return true;
3287               default:
3288                 fatal("op idx %i out of bounds\n", opIdx);
3289                 return false;
3290             }
3291         } // isSrcOperand
3292
3293         bool
3294         isDstOperand(int opIdx) override
3295         {
3296             switch (opIdx) {
3297               case 0: //ssrc
3298                 return false;
3299               case 1: //simm16
3300                 return false;
3301               default:
3302                 fatal("op idx %i out of bounds\n", opIdx);
3303                 return false;
3304             }
3305         } // isDstOperand
3306
3307         void execute(GPUDynInstPtr) override;
3308     }; // Inst_SOPK__S_CMPK_GE_I32
3309
3310     class Inst_SOPK__S_CMPK_LT_I32 : public Inst_SOPK
3311     {
3312       public:
3313         Inst_SOPK__S_CMPK_LT_I32(InFmt_SOPK*);
3314         ~Inst_SOPK__S_CMPK_LT_I32();
3315
3316         int
3317         getNumOperands() override
3318         {
3319             return numDstRegOperands() + numSrcRegOperands();
3320         } // getNumOperands
3321
3322         int numDstRegOperands() override { return 0; }
3323         int numSrcRegOperands() override { return 2; }
3324
3325         int
3326         getOperandSize(int opIdx) override
3327         {
3328             switch (opIdx) {
3329               case 0: //ssrc
3330                 return 4;
3331               case 1: //simm16
3332                 return 2;
3333               default:
3334                 fatal("op idx %i out of bounds\n", opIdx);
3335                 return -1;
3336             }
3337         } // getOperandSize
3338
3339         bool
3340         isSrcOperand(int opIdx) override
3341         {
3342             switch (opIdx) {
3343               case 0: //ssrc
3344                 return true;
3345               case 1: //simm16
3346                 return true;
3347               default:
3348                 fatal("op idx %i out of bounds\n", opIdx);
3349                 return false;
3350             }
3351         } // isSrcOperand
3352
3353         bool
3354         isDstOperand(int opIdx) override
3355         {
3356             switch (opIdx) {
3357               case 0: //ssrc
3358                 return false;
3359               case 1: //simm16
3360                 return false;
3361               default:
3362                 fatal("op idx %i out of bounds\n", opIdx);
3363                 return false;
3364             }
3365         } // isDstOperand
3366
3367         void execute(GPUDynInstPtr) override;
3368     }; // Inst_SOPK__S_CMPK_LT_I32
3369
3370     class Inst_SOPK__S_CMPK_LE_I32 : public Inst_SOPK
3371     {
3372       public:
3373         Inst_SOPK__S_CMPK_LE_I32(InFmt_SOPK*);
3374         ~Inst_SOPK__S_CMPK_LE_I32();
3375
3376         int
3377         getNumOperands() override
3378         {
3379             return numDstRegOperands() + numSrcRegOperands();
3380         } // getNumOperands
3381
3382         int numDstRegOperands() override { return 0; }
3383         int numSrcRegOperands() override { return 2; }
3384
3385         int
3386         getOperandSize(int opIdx) override
3387         {
3388             switch (opIdx) {
3389               case 0: //ssrc
3390                 return 4;
3391               case 1: //simm16
3392                 return 2;
3393               default:
3394                 fatal("op idx %i out of bounds\n", opIdx);
3395                 return -1;
3396             }
3397         } // getOperandSize
3398
3399         bool
3400         isSrcOperand(int opIdx) override
3401         {
3402             switch (opIdx) {
3403               case 0: //ssrc
3404                 return true;
3405               case 1: //simm16
3406                 return true;
3407               default:
3408                 fatal("op idx %i out of bounds\n", opIdx);
3409                 return false;
3410             }
3411         } // isSrcOperand
3412
3413         bool
3414         isDstOperand(int opIdx) override
3415         {
3416             switch (opIdx) {
3417               case 0: //ssrc
3418                 return false;
3419               case 1: //simm16
3420                 return false;
3421               default:
3422                 fatal("op idx %i out of bounds\n", opIdx);
3423                 return false;
3424             }
3425         } // isDstOperand
3426
3427         void execute(GPUDynInstPtr) override;
3428     }; // Inst_SOPK__S_CMPK_LE_I32
3429
3430     class Inst_SOPK__S_CMPK_EQ_U32 : public Inst_SOPK
3431     {
3432       public:
3433         Inst_SOPK__S_CMPK_EQ_U32(InFmt_SOPK*);
3434         ~Inst_SOPK__S_CMPK_EQ_U32();
3435
3436         int
3437         getNumOperands() override
3438         {
3439             return numDstRegOperands() + numSrcRegOperands();
3440         } // getNumOperands
3441
3442         int numDstRegOperands() override { return 0; }
3443         int numSrcRegOperands() override { return 2; }
3444
3445         int
3446         getOperandSize(int opIdx) override
3447         {
3448             switch (opIdx) {
3449               case 0: //ssrc
3450                 return 4;
3451               case 1: //simm16
3452                 return 2;
3453               default:
3454                 fatal("op idx %i out of bounds\n", opIdx);
3455                 return -1;
3456             }
3457         } // getOperandSize
3458
3459         bool
3460         isSrcOperand(int opIdx) override
3461         {
3462             switch (opIdx) {
3463               case 0: //ssrc
3464                 return true;
3465               case 1: //simm16
3466                 return true;
3467               default:
3468                 fatal("op idx %i out of bounds\n", opIdx);
3469                 return false;
3470             }
3471         } // isSrcOperand
3472
3473         bool
3474         isDstOperand(int opIdx) override
3475         {
3476             switch (opIdx) {
3477               case 0: //ssrc
3478                 return false;
3479               case 1: //simm16
3480                 return false;
3481               default:
3482                 fatal("op idx %i out of bounds\n", opIdx);
3483                 return false;
3484             }
3485         } // isDstOperand
3486
3487         void execute(GPUDynInstPtr) override;
3488     }; // Inst_SOPK__S_CMPK_EQ_U32
3489
3490     class Inst_SOPK__S_CMPK_LG_U32 : public Inst_SOPK
3491     {
3492       public:
3493         Inst_SOPK__S_CMPK_LG_U32(InFmt_SOPK*);
3494         ~Inst_SOPK__S_CMPK_LG_U32();
3495
3496         int
3497         getNumOperands() override
3498         {
3499             return numDstRegOperands() + numSrcRegOperands();
3500         } // getNumOperands
3501
3502         int numDstRegOperands() override { return 0; }
3503         int numSrcRegOperands() override { return 2; }
3504
3505         int
3506         getOperandSize(int opIdx) override
3507         {
3508             switch (opIdx) {
3509               case 0: //ssrc
3510                 return 4;
3511               case 1: //simm16
3512                 return 2;
3513               default:
3514                 fatal("op idx %i out of bounds\n", opIdx);
3515                 return -1;
3516             }
3517         } // getOperandSize
3518
3519         bool
3520         isSrcOperand(int opIdx) override
3521         {
3522             switch (opIdx) {
3523               case 0: //ssrc
3524                 return true;
3525               case 1: //simm16
3526                 return true;
3527               default:
3528                 fatal("op idx %i out of bounds\n", opIdx);
3529                 return false;
3530             }
3531         } // isSrcOperand
3532
3533         bool
3534         isDstOperand(int opIdx) override
3535         {
3536             switch (opIdx) {
3537               case 0: //ssrc
3538                 return false;
3539               case 1: //simm16
3540                 return false;
3541               default:
3542                 fatal("op idx %i out of bounds\n", opIdx);
3543                 return false;
3544             }
3545         } // isDstOperand
3546
3547         void execute(GPUDynInstPtr) override;
3548     }; // Inst_SOPK__S_CMPK_LG_U32
3549
3550     class Inst_SOPK__S_CMPK_GT_U32 : public Inst_SOPK
3551     {
3552       public:
3553         Inst_SOPK__S_CMPK_GT_U32(InFmt_SOPK*);
3554         ~Inst_SOPK__S_CMPK_GT_U32();
3555
3556         int
3557         getNumOperands() override
3558         {
3559             return numDstRegOperands() + numSrcRegOperands();
3560         } // getNumOperands
3561
3562         int numDstRegOperands() override { return 0; }
3563         int numSrcRegOperands() override { return 2; }
3564
3565         int
3566         getOperandSize(int opIdx) override
3567         {
3568             switch (opIdx) {
3569               case 0: //ssrc
3570                 return 4;
3571               case 1: //simm16
3572                 return 2;
3573               default:
3574                 fatal("op idx %i out of bounds\n", opIdx);
3575                 return -1;
3576             }
3577         } // getOperandSize
3578
3579         bool
3580         isSrcOperand(int opIdx) override
3581         {
3582             switch (opIdx) {
3583               case 0: //ssrc
3584                 return true;
3585               case 1: //simm16
3586                 return true;
3587               default:
3588                 fatal("op idx %i out of bounds\n", opIdx);
3589                 return false;
3590             }
3591         } // isSrcOperand
3592
3593         bool
3594         isDstOperand(int opIdx) override
3595         {
3596             switch (opIdx) {
3597               case 0: //ssrc
3598                 return false;
3599               case 1: //simm16
3600                 return false;
3601               default:
3602                 fatal("op idx %i out of bounds\n", opIdx);
3603                 return false;
3604             }
3605         } // isDstOperand
3606
3607         void execute(GPUDynInstPtr) override;
3608     }; // Inst_SOPK__S_CMPK_GT_U32
3609
3610     class Inst_SOPK__S_CMPK_GE_U32 : public Inst_SOPK
3611     {
3612       public:
3613         Inst_SOPK__S_CMPK_GE_U32(InFmt_SOPK*);
3614         ~Inst_SOPK__S_CMPK_GE_U32();
3615
3616         int
3617         getNumOperands() override
3618         {
3619             return numDstRegOperands() + numSrcRegOperands();
3620         } // getNumOperands
3621
3622         int numDstRegOperands() override { return 0; }
3623         int numSrcRegOperands() override { return 2; }
3624
3625         int
3626         getOperandSize(int opIdx) override
3627         {
3628             switch (opIdx) {
3629               case 0: //ssrc
3630                 return 4;
3631               case 1: //simm16
3632                 return 2;
3633               default:
3634                 fatal("op idx %i out of bounds\n", opIdx);
3635                 return -1;
3636             }
3637         } // getOperandSize
3638
3639         bool
3640         isSrcOperand(int opIdx) override
3641         {
3642             switch (opIdx) {
3643               case 0: //ssrc
3644                 return true;
3645               case 1: //simm16
3646                 return true;
3647               default:
3648                 fatal("op idx %i out of bounds\n", opIdx);
3649                 return false;
3650             }
3651         } // isSrcOperand
3652
3653         bool
3654         isDstOperand(int opIdx) override
3655         {
3656             switch (opIdx) {
3657               case 0: //ssrc
3658                 return false;
3659               case 1: //simm16
3660                 return false;
3661               default:
3662                 fatal("op idx %i out of bounds\n", opIdx);
3663                 return false;
3664             }
3665         } // isDstOperand
3666
3667         void execute(GPUDynInstPtr) override;
3668     }; // Inst_SOPK__S_CMPK_GE_U32
3669
3670     class Inst_SOPK__S_CMPK_LT_U32 : public Inst_SOPK
3671     {
3672       public:
3673         Inst_SOPK__S_CMPK_LT_U32(InFmt_SOPK*);
3674         ~Inst_SOPK__S_CMPK_LT_U32();
3675
3676         int
3677         getNumOperands() override
3678         {
3679             return numDstRegOperands() + numSrcRegOperands();
3680         } // getNumOperands
3681
3682         int numDstRegOperands() override { return 0; }
3683         int numSrcRegOperands() override { return 2; }
3684
3685         int
3686         getOperandSize(int opIdx) override
3687         {
3688             switch (opIdx) {
3689               case 0: //ssrc
3690                 return 4;
3691               case 1: //simm16
3692                 return 2;
3693               default:
3694                 fatal("op idx %i out of bounds\n", opIdx);
3695                 return -1;
3696             }
3697         } // getOperandSize
3698
3699         bool
3700         isSrcOperand(int opIdx) override
3701         {
3702             switch (opIdx) {
3703               case 0: //ssrc
3704                 return true;
3705               case 1: //simm16
3706                 return true;
3707               default:
3708                 fatal("op idx %i out of bounds\n", opIdx);
3709                 return false;
3710             }
3711         } // isSrcOperand
3712
3713         bool
3714         isDstOperand(int opIdx) override
3715         {
3716             switch (opIdx) {
3717               case 0: //ssrc
3718                 return false;
3719               case 1: //simm16
3720                 return false;
3721               default:
3722                 fatal("op idx %i out of bounds\n", opIdx);
3723                 return false;
3724             }
3725         } // isDstOperand
3726
3727         void execute(GPUDynInstPtr) override;
3728     }; // Inst_SOPK__S_CMPK_LT_U32
3729
3730     class Inst_SOPK__S_CMPK_LE_U32 : public Inst_SOPK
3731     {
3732       public:
3733         Inst_SOPK__S_CMPK_LE_U32(InFmt_SOPK*);
3734         ~Inst_SOPK__S_CMPK_LE_U32();
3735
3736         int
3737         getNumOperands() override
3738         {
3739             return numDstRegOperands() + numSrcRegOperands();
3740         } // getNumOperands
3741
3742         int numDstRegOperands() override { return 0; }
3743         int numSrcRegOperands() override { return 2; }
3744
3745         int
3746         getOperandSize(int opIdx) override
3747         {
3748             switch (opIdx) {
3749               case 0: //ssrc
3750                 return 4;
3751               case 1: //simm16
3752                 return 2;
3753               default:
3754                 fatal("op idx %i out of bounds\n", opIdx);
3755                 return -1;
3756             }
3757         } // getOperandSize
3758
3759         bool
3760         isSrcOperand(int opIdx) override
3761         {
3762             switch (opIdx) {
3763               case 0: //ssrc
3764                 return true;
3765               case 1: //simm16
3766                 return true;
3767               default:
3768                 fatal("op idx %i out of bounds\n", opIdx);
3769                 return false;
3770             }
3771         } // isSrcOperand
3772
3773         bool
3774         isDstOperand(int opIdx) override
3775         {
3776             switch (opIdx) {
3777               case 0: //ssrc
3778                 return false;
3779               case 1: //simm16
3780                 return false;
3781               default:
3782                 fatal("op idx %i out of bounds\n", opIdx);
3783                 return false;
3784             }
3785         } // isDstOperand
3786
3787         void execute(GPUDynInstPtr) override;
3788     }; // Inst_SOPK__S_CMPK_LE_U32
3789
3790     class Inst_SOPK__S_ADDK_I32 : public Inst_SOPK
3791     {
3792       public:
3793         Inst_SOPK__S_ADDK_I32(InFmt_SOPK*);
3794         ~Inst_SOPK__S_ADDK_I32();
3795
3796         int
3797         getNumOperands() override
3798         {
3799             return numDstRegOperands() + numSrcRegOperands();
3800         } // getNumOperands
3801
3802         int numDstRegOperands() override { return 1; }
3803         int numSrcRegOperands() override { return 1; }
3804
3805         int
3806         getOperandSize(int opIdx) override
3807         {
3808             switch (opIdx) {
3809               case 0: //simm16
3810                 return 2;
3811               case 1: //sdst
3812                 return 4;
3813               default:
3814                 fatal("op idx %i out of bounds\n", opIdx);
3815                 return -1;
3816             }
3817         } // getOperandSize
3818
3819         bool
3820         isSrcOperand(int opIdx) override
3821         {
3822             switch (opIdx) {
3823               case 0: //simm16
3824                 return true;
3825               case 1: //sdst
3826                 return false;
3827               default:
3828                 fatal("op idx %i out of bounds\n", opIdx);
3829                 return false;
3830             }
3831         } // isSrcOperand
3832
3833         bool
3834         isDstOperand(int opIdx) override
3835         {
3836             switch (opIdx) {
3837               case 0: //simm16
3838                 return false;
3839               case 1: //sdst
3840                 return true;
3841               default:
3842                 fatal("op idx %i out of bounds\n", opIdx);
3843                 return false;
3844             }
3845         } // isDstOperand
3846
3847         void execute(GPUDynInstPtr) override;
3848     }; // Inst_SOPK__S_ADDK_I32
3849
3850     class Inst_SOPK__S_MULK_I32 : public Inst_SOPK
3851     {
3852       public:
3853         Inst_SOPK__S_MULK_I32(InFmt_SOPK*);
3854         ~Inst_SOPK__S_MULK_I32();
3855
3856         int
3857         getNumOperands() override
3858         {
3859             return numDstRegOperands() + numSrcRegOperands();
3860         } // getNumOperands
3861
3862         int numDstRegOperands() override { return 1; }
3863         int numSrcRegOperands() override { return 1; }
3864
3865         int
3866         getOperandSize(int opIdx) override
3867         {
3868             switch (opIdx) {
3869               case 0: //simm16
3870                 return 2;
3871               case 1: //sdst
3872                 return 4;
3873               default:
3874                 fatal("op idx %i out of bounds\n", opIdx);
3875                 return -1;
3876             }
3877         } // getOperandSize
3878
3879         bool
3880         isSrcOperand(int opIdx) override
3881         {
3882             switch (opIdx) {
3883               case 0: //simm16
3884                 return true;
3885               case 1: //sdst
3886                 return false;
3887               default:
3888                 fatal("op idx %i out of bounds\n", opIdx);
3889                 return false;
3890             }
3891         } // isSrcOperand
3892
3893         bool
3894         isDstOperand(int opIdx) override
3895         {
3896             switch (opIdx) {
3897               case 0: //simm16
3898                 return false;
3899               case 1: //sdst
3900                 return true;
3901               default:
3902                 fatal("op idx %i out of bounds\n", opIdx);
3903                 return false;
3904             }
3905         } // isDstOperand
3906
3907         void execute(GPUDynInstPtr) override;
3908     }; // Inst_SOPK__S_MULK_I32
3909
3910     class Inst_SOPK__S_CBRANCH_I_FORK : public Inst_SOPK
3911     {
3912       public:
3913         Inst_SOPK__S_CBRANCH_I_FORK(InFmt_SOPK*);
3914         ~Inst_SOPK__S_CBRANCH_I_FORK();
3915
3916         int
3917         getNumOperands() override
3918         {
3919             return numDstRegOperands() + numSrcRegOperands();
3920         } // getNumOperands
3921
3922         int numDstRegOperands() override { return 0; }
3923         int numSrcRegOperands() override { return 2; }
3924
3925         int
3926         getOperandSize(int opIdx) override
3927         {
3928             switch (opIdx) {
3929               case 0: //sdst
3930                 return 8;
3931               case 1: //
3932                 return 16;
3933               default:
3934                 fatal("op idx %i out of bounds\n", opIdx);
3935                 return -1;
3936             }
3937         } // getOperandSize
3938
3939         bool
3940         isSrcOperand(int opIdx) override
3941         {
3942             switch (opIdx) {
3943               case 0: //sdst
3944                 return true;
3945               case 1: //
3946                 return true;
3947               default:
3948                 fatal("op idx %i out of bounds\n", opIdx);
3949                 return false;
3950             }
3951         } // isSrcOperand
3952
3953         bool
3954         isDstOperand(int opIdx) override
3955         {
3956             switch (opIdx) {
3957               case 0: //sdst
3958                 return false;
3959               case 1: //
3960                 return false;
3961               default:
3962                 fatal("op idx %i out of bounds\n", opIdx);
3963                 return false;
3964             }
3965         } // isDstOperand
3966
3967         void execute(GPUDynInstPtr) override;
3968     }; // Inst_SOPK__S_CBRANCH_I_FORK
3969
3970     class Inst_SOPK__S_GETREG_B32 : public Inst_SOPK
3971     {
3972       public:
3973         Inst_SOPK__S_GETREG_B32(InFmt_SOPK*);
3974         ~Inst_SOPK__S_GETREG_B32();
3975
3976         int
3977         getNumOperands() override
3978         {
3979             return numDstRegOperands() + numSrcRegOperands();
3980         } // getNumOperands
3981
3982         int numDstRegOperands() override { return 1; }
3983         int numSrcRegOperands() override { return 1; }
3984
3985         int
3986         getOperandSize(int opIdx) override
3987         {
3988             switch (opIdx) {
3989               case 0: //simm16
3990                 return 2;
3991               case 1: //sdst
3992                 return 4;
3993               default:
3994                 fatal("op idx %i out of bounds\n", opIdx);
3995                 return -1;
3996             }
3997         } // getOperandSize
3998
3999         bool
4000         isSrcOperand(int opIdx) override
4001         {
4002             switch (opIdx) {
4003               case 0: //simm16
4004                 return true;
4005               case 1: //sdst
4006                 return false;
4007               default:
4008                 fatal("op idx %i out of bounds\n", opIdx);
4009                 return false;
4010             }
4011         } // isSrcOperand
4012
4013         bool
4014         isDstOperand(int opIdx) override
4015         {
4016             switch (opIdx) {
4017               case 0: //simm16
4018                 return false;
4019               case 1: //sdst
4020                 return true;
4021               default:
4022                 fatal("op idx %i out of bounds\n", opIdx);
4023                 return false;
4024             }
4025         } // isDstOperand
4026
4027         void execute(GPUDynInstPtr) override;
4028     }; // Inst_SOPK__S_GETREG_B32
4029
4030     class Inst_SOPK__S_SETREG_B32 : public Inst_SOPK
4031     {
4032       public:
4033         Inst_SOPK__S_SETREG_B32(InFmt_SOPK*);
4034         ~Inst_SOPK__S_SETREG_B32();
4035
4036         int
4037         getNumOperands() override
4038         {
4039             return numDstRegOperands() + numSrcRegOperands();
4040         } // getNumOperands
4041
4042         int numDstRegOperands() override { return 1; }
4043         int numSrcRegOperands() override { return 1; }
4044
4045         int
4046         getOperandSize(int opIdx) override
4047         {
4048             switch (opIdx) {
4049               case 0: //ssrc
4050                 return 4;
4051               case 1: //simm16
4052                 return 2;
4053               default:
4054                 fatal("op idx %i out of bounds\n", opIdx);
4055                 return -1;
4056             }
4057         } // getOperandSize
4058
4059         bool
4060         isSrcOperand(int opIdx) override
4061         {
4062             switch (opIdx) {
4063               case 0: //ssrc
4064                 return true;
4065               case 1: //simm16
4066                 return false;
4067               default:
4068                 fatal("op idx %i out of bounds\n", opIdx);
4069                 return false;
4070             }
4071         } // isSrcOperand
4072
4073         bool
4074         isDstOperand(int opIdx) override
4075         {
4076             switch (opIdx) {
4077               case 0: //ssrc
4078                 return false;
4079               case 1: //simm16
4080                 return true;
4081               default:
4082                 fatal("op idx %i out of bounds\n", opIdx);
4083                 return false;
4084             }
4085         } // isDstOperand
4086
4087         void execute(GPUDynInstPtr) override;
4088     }; // Inst_SOPK__S_SETREG_B32
4089
4090     class Inst_SOPK__S_SETREG_IMM32_B32 : public Inst_SOPK
4091     {
4092       public:
4093         Inst_SOPK__S_SETREG_IMM32_B32(InFmt_SOPK*);
4094         ~Inst_SOPK__S_SETREG_IMM32_B32();
4095
4096         int
4097         getNumOperands() override
4098         {
4099             return numDstRegOperands() + numSrcRegOperands();
4100         } // getNumOperands
4101
4102         int numDstRegOperands() override { return 1; }
4103         int numSrcRegOperands() override { return 1; }
4104
4105         int
4106         getOperandSize(int opIdx) override
4107         {
4108             switch (opIdx) {
4109               case 0: //simm32
4110                 return 4;
4111               case 1: //simm16
4112                 return 2;
4113               default:
4114                 fatal("op idx %i out of bounds\n", opIdx);
4115                 return -1;
4116             }
4117         } // getOperandSize
4118
4119         bool
4120         isSrcOperand(int opIdx) override
4121         {
4122             switch (opIdx) {
4123               case 0: //simm32
4124                 return true;
4125               case 1: //simm16
4126                 return false;
4127               default:
4128                 fatal("op idx %i out of bounds\n", opIdx);
4129                 return false;
4130             }
4131         } // isSrcOperand
4132
4133         bool
4134         isDstOperand(int opIdx) override
4135         {
4136             switch (opIdx) {
4137               case 0: //simm32
4138                 return false;
4139               case 1: //simm16
4140                 return true;
4141               default:
4142                 fatal("op idx %i out of bounds\n", opIdx);
4143                 return false;
4144             }
4145         } // isDstOperand
4146
4147         void execute(GPUDynInstPtr) override;
4148     }; // Inst_SOPK__S_SETREG_IMM32_B32
4149
4150     class Inst_SOP1__S_MOV_B32 : public Inst_SOP1
4151     {
4152       public:
4153         Inst_SOP1__S_MOV_B32(InFmt_SOP1*);
4154         ~Inst_SOP1__S_MOV_B32();
4155
4156         int
4157         getNumOperands() override
4158         {
4159             return numDstRegOperands() + numSrcRegOperands();
4160         } // getNumOperands
4161
4162         int numDstRegOperands() override { return 1; }
4163         int numSrcRegOperands() override { return 1; }
4164
4165         int
4166         getOperandSize(int opIdx) override
4167         {
4168             switch (opIdx) {
4169               case 0: //ssrc
4170                 return 4;
4171               case 1: //sdst
4172                 return 4;
4173               default:
4174                 fatal("op idx %i out of bounds\n", opIdx);
4175                 return -1;
4176             }
4177         } // getOperandSize
4178
4179         bool
4180         isSrcOperand(int opIdx) override
4181         {
4182             switch (opIdx) {
4183               case 0: //ssrc
4184                 return true;
4185               case 1: //sdst
4186                 return false;
4187               default:
4188                 fatal("op idx %i out of bounds\n", opIdx);
4189                 return false;
4190             }
4191         } // isSrcOperand
4192
4193         bool
4194         isDstOperand(int opIdx) override
4195         {
4196             switch (opIdx) {
4197               case 0: //ssrc
4198                 return false;
4199               case 1: //sdst
4200                 return true;
4201               default:
4202                 fatal("op idx %i out of bounds\n", opIdx);
4203                 return false;
4204             }
4205         } // isDstOperand
4206
4207         void execute(GPUDynInstPtr) override;
4208     }; // Inst_SOP1__S_MOV_B32
4209
4210     class Inst_SOP1__S_MOV_B64 : public Inst_SOP1
4211     {
4212       public:
4213         Inst_SOP1__S_MOV_B64(InFmt_SOP1*);
4214         ~Inst_SOP1__S_MOV_B64();
4215
4216         int
4217         getNumOperands() override
4218         {
4219             return numDstRegOperands() + numSrcRegOperands();
4220         } // getNumOperands
4221
4222         int numDstRegOperands() override { return 1; }
4223         int numSrcRegOperands() override { return 1; }
4224
4225         int
4226         getOperandSize(int opIdx) override
4227         {
4228             switch (opIdx) {
4229               case 0: //ssrc
4230                 return 8;
4231               case 1: //sdst
4232                 return 8;
4233               default:
4234                 fatal("op idx %i out of bounds\n", opIdx);
4235                 return -1;
4236             }
4237         } // getOperandSize
4238
4239         bool
4240         isSrcOperand(int opIdx) override
4241         {
4242             switch (opIdx) {
4243               case 0: //ssrc
4244                 return true;
4245               case 1: //sdst
4246                 return false;
4247               default:
4248                 fatal("op idx %i out of bounds\n", opIdx);
4249                 return false;
4250             }
4251         } // isSrcOperand
4252
4253         bool
4254         isDstOperand(int opIdx) override
4255         {
4256             switch (opIdx) {
4257               case 0: //ssrc
4258                 return false;
4259               case 1: //sdst
4260                 return true;
4261               default:
4262                 fatal("op idx %i out of bounds\n", opIdx);
4263                 return false;
4264             }
4265         } // isDstOperand
4266
4267         void execute(GPUDynInstPtr) override;
4268     }; // Inst_SOP1__S_MOV_B64
4269
4270     class Inst_SOP1__S_CMOV_B32 : public Inst_SOP1
4271     {
4272       public:
4273         Inst_SOP1__S_CMOV_B32(InFmt_SOP1*);
4274         ~Inst_SOP1__S_CMOV_B32();
4275
4276         int
4277         getNumOperands() override
4278         {
4279             return numDstRegOperands() + numSrcRegOperands();
4280         } // getNumOperands
4281
4282         int numDstRegOperands() override { return 1; }
4283         int numSrcRegOperands() override { return 1; }
4284
4285         int
4286         getOperandSize(int opIdx) override
4287         {
4288             switch (opIdx) {
4289               case 0: //ssrc
4290                 return 4;
4291               case 1: //sdst
4292                 return 4;
4293               default:
4294                 fatal("op idx %i out of bounds\n", opIdx);
4295                 return -1;
4296             }
4297         } // getOperandSize
4298
4299         bool
4300         isSrcOperand(int opIdx) override
4301         {
4302             switch (opIdx) {
4303               case 0: //ssrc
4304                 return true;
4305               case 1: //sdst
4306                 return false;
4307               default:
4308                 fatal("op idx %i out of bounds\n", opIdx);
4309                 return false;
4310             }
4311         } // isSrcOperand
4312
4313         bool
4314         isDstOperand(int opIdx) override
4315         {
4316             switch (opIdx) {
4317               case 0: //ssrc
4318                 return false;
4319               case 1: //sdst
4320                 return true;
4321               default:
4322                 fatal("op idx %i out of bounds\n", opIdx);
4323                 return false;
4324             }
4325         } // isDstOperand
4326
4327         void execute(GPUDynInstPtr) override;
4328     }; // Inst_SOP1__S_CMOV_B32
4329
4330     class Inst_SOP1__S_CMOV_B64 : public Inst_SOP1
4331     {
4332       public:
4333         Inst_SOP1__S_CMOV_B64(InFmt_SOP1*);
4334         ~Inst_SOP1__S_CMOV_B64();
4335
4336         int
4337         getNumOperands() override
4338         {
4339             return numDstRegOperands() + numSrcRegOperands();
4340         } // getNumOperands
4341
4342         int numDstRegOperands() override { return 1; }
4343         int numSrcRegOperands() override { return 1; }
4344
4345         int
4346         getOperandSize(int opIdx) override
4347         {
4348             switch (opIdx) {
4349               case 0: //ssrc
4350                 return 8;
4351               case 1: //sdst
4352                 return 8;
4353               default:
4354                 fatal("op idx %i out of bounds\n", opIdx);
4355                 return -1;
4356             }
4357         } // getOperandSize
4358
4359         bool
4360         isSrcOperand(int opIdx) override
4361         {
4362             switch (opIdx) {
4363               case 0: //ssrc
4364                 return true;
4365               case 1: //sdst
4366                 return false;
4367               default:
4368                 fatal("op idx %i out of bounds\n", opIdx);
4369                 return false;
4370             }
4371         } // isSrcOperand
4372
4373         bool
4374         isDstOperand(int opIdx) override
4375         {
4376             switch (opIdx) {
4377               case 0: //ssrc
4378                 return false;
4379               case 1: //sdst
4380                 return true;
4381               default:
4382                 fatal("op idx %i out of bounds\n", opIdx);
4383                 return false;
4384             }
4385         } // isDstOperand
4386
4387         void execute(GPUDynInstPtr) override;
4388     }; // Inst_SOP1__S_CMOV_B64
4389
4390     class Inst_SOP1__S_NOT_B32 : public Inst_SOP1
4391     {
4392       public:
4393         Inst_SOP1__S_NOT_B32(InFmt_SOP1*);
4394         ~Inst_SOP1__S_NOT_B32();
4395
4396         int
4397         getNumOperands() override
4398         {
4399             return numDstRegOperands() + numSrcRegOperands();
4400         } // getNumOperands
4401
4402         int numDstRegOperands() override { return 1; }
4403         int numSrcRegOperands() override { return 1; }
4404
4405         int
4406         getOperandSize(int opIdx) override
4407         {
4408             switch (opIdx) {
4409               case 0: //ssrc
4410                 return 4;
4411               case 1: //sdst
4412                 return 4;
4413               default:
4414                 fatal("op idx %i out of bounds\n", opIdx);
4415                 return -1;
4416             }
4417         } // getOperandSize
4418
4419         bool
4420         isSrcOperand(int opIdx) override
4421         {
4422             switch (opIdx) {
4423               case 0: //ssrc
4424                 return true;
4425               case 1: //sdst
4426                 return false;
4427               default:
4428                 fatal("op idx %i out of bounds\n", opIdx);
4429                 return false;
4430             }
4431         } // isSrcOperand
4432
4433         bool
4434         isDstOperand(int opIdx) override
4435         {
4436             switch (opIdx) {
4437               case 0: //ssrc
4438                 return false;
4439               case 1: //sdst
4440                 return true;
4441               default:
4442                 fatal("op idx %i out of bounds\n", opIdx);
4443                 return false;
4444             }
4445         } // isDstOperand
4446
4447         void execute(GPUDynInstPtr) override;
4448     }; // Inst_SOP1__S_NOT_B32
4449
4450     class Inst_SOP1__S_NOT_B64 : public Inst_SOP1
4451     {
4452       public:
4453         Inst_SOP1__S_NOT_B64(InFmt_SOP1*);
4454         ~Inst_SOP1__S_NOT_B64();
4455
4456         int
4457         getNumOperands() override
4458         {
4459             return numDstRegOperands() + numSrcRegOperands();
4460         } // getNumOperands
4461
4462         int numDstRegOperands() override { return 1; }
4463         int numSrcRegOperands() override { return 1; }
4464
4465         int
4466         getOperandSize(int opIdx) override
4467         {
4468             switch (opIdx) {
4469               case 0: //ssrc
4470                 return 8;
4471               case 1: //sdst
4472                 return 8;
4473               default:
4474                 fatal("op idx %i out of bounds\n", opIdx);
4475                 return -1;
4476             }
4477         } // getOperandSize
4478
4479         bool
4480         isSrcOperand(int opIdx) override
4481         {
4482             switch (opIdx) {
4483               case 0: //ssrc
4484                 return true;
4485               case 1: //sdst
4486                 return false;
4487               default:
4488                 fatal("op idx %i out of bounds\n", opIdx);
4489                 return false;
4490             }
4491         } // isSrcOperand
4492
4493         bool
4494         isDstOperand(int opIdx) override
4495         {
4496             switch (opIdx) {
4497               case 0: //ssrc
4498                 return false;
4499               case 1: //sdst
4500                 return true;
4501               default:
4502                 fatal("op idx %i out of bounds\n", opIdx);
4503                 return false;
4504             }
4505         } // isDstOperand
4506
4507         void execute(GPUDynInstPtr) override;
4508     }; // Inst_SOP1__S_NOT_B64
4509
4510     class Inst_SOP1__S_WQM_B32 : public Inst_SOP1
4511     {
4512       public:
4513         Inst_SOP1__S_WQM_B32(InFmt_SOP1*);
4514         ~Inst_SOP1__S_WQM_B32();
4515
4516         int
4517         getNumOperands() override
4518         {
4519             return numDstRegOperands() + numSrcRegOperands();
4520         } // getNumOperands
4521
4522         int numDstRegOperands() override { return 1; }
4523         int numSrcRegOperands() override { return 1; }
4524
4525         int
4526         getOperandSize(int opIdx) override
4527         {
4528             switch (opIdx) {
4529               case 0: //ssrc
4530                 return 4;
4531               case 1: //sdst
4532                 return 4;
4533               default:
4534                 fatal("op idx %i out of bounds\n", opIdx);
4535                 return -1;
4536             }
4537         } // getOperandSize
4538
4539         bool
4540         isSrcOperand(int opIdx) override
4541         {
4542             switch (opIdx) {
4543               case 0: //ssrc
4544                 return true;
4545               case 1: //sdst
4546                 return false;
4547               default:
4548                 fatal("op idx %i out of bounds\n", opIdx);
4549                 return false;
4550             }
4551         } // isSrcOperand
4552
4553         bool
4554         isDstOperand(int opIdx) override
4555         {
4556             switch (opIdx) {
4557               case 0: //ssrc
4558                 return false;
4559               case 1: //sdst
4560                 return true;
4561               default:
4562                 fatal("op idx %i out of bounds\n", opIdx);
4563                 return false;
4564             }
4565         } // isDstOperand
4566
4567         void execute(GPUDynInstPtr) override;
4568     }; // Inst_SOP1__S_WQM_B32
4569
4570     class Inst_SOP1__S_WQM_B64 : public Inst_SOP1
4571     {
4572       public:
4573         Inst_SOP1__S_WQM_B64(InFmt_SOP1*);
4574         ~Inst_SOP1__S_WQM_B64();
4575
4576         int
4577         getNumOperands() override
4578         {
4579             return numDstRegOperands() + numSrcRegOperands();
4580         } // getNumOperands
4581
4582         int numDstRegOperands() override { return 1; }
4583         int numSrcRegOperands() override { return 1; }
4584
4585         int
4586         getOperandSize(int opIdx) override
4587         {
4588             switch (opIdx) {
4589               case 0: //ssrc
4590                 return 8;
4591               case 1: //sdst
4592                 return 8;
4593               default:
4594                 fatal("op idx %i out of bounds\n", opIdx);
4595                 return -1;
4596             }
4597         } // getOperandSize
4598
4599         bool
4600         isSrcOperand(int opIdx) override
4601         {
4602             switch (opIdx) {
4603               case 0: //ssrc
4604                 return true;
4605               case 1: //sdst
4606                 return false;
4607               default:
4608                 fatal("op idx %i out of bounds\n", opIdx);
4609                 return false;
4610             }
4611         } // isSrcOperand
4612
4613         bool
4614         isDstOperand(int opIdx) override
4615         {
4616             switch (opIdx) {
4617               case 0: //ssrc
4618                 return false;
4619               case 1: //sdst
4620                 return true;
4621               default:
4622                 fatal("op idx %i out of bounds\n", opIdx);
4623                 return false;
4624             }
4625         } // isDstOperand
4626
4627         void execute(GPUDynInstPtr) override;
4628     }; // Inst_SOP1__S_WQM_B64
4629
4630     class Inst_SOP1__S_BREV_B32 : public Inst_SOP1
4631     {
4632       public:
4633         Inst_SOP1__S_BREV_B32(InFmt_SOP1*);
4634         ~Inst_SOP1__S_BREV_B32();
4635
4636         int
4637         getNumOperands() override
4638         {
4639             return numDstRegOperands() + numSrcRegOperands();
4640         } // getNumOperands
4641
4642         int numDstRegOperands() override { return 1; }
4643         int numSrcRegOperands() override { return 1; }
4644
4645         int
4646         getOperandSize(int opIdx) override
4647         {
4648             switch (opIdx) {
4649               case 0: //ssrc
4650                 return 4;
4651               case 1: //sdst
4652                 return 4;
4653               default:
4654                 fatal("op idx %i out of bounds\n", opIdx);
4655                 return -1;
4656             }
4657         } // getOperandSize
4658
4659         bool
4660         isSrcOperand(int opIdx) override
4661         {
4662             switch (opIdx) {
4663               case 0: //ssrc
4664                 return true;
4665               case 1: //sdst
4666                 return false;
4667               default:
4668                 fatal("op idx %i out of bounds\n", opIdx);
4669                 return false;
4670             }
4671         } // isSrcOperand
4672
4673         bool
4674         isDstOperand(int opIdx) override
4675         {
4676             switch (opIdx) {
4677               case 0: //ssrc
4678                 return false;
4679               case 1: //sdst
4680                 return true;
4681               default:
4682                 fatal("op idx %i out of bounds\n", opIdx);
4683                 return false;
4684             }
4685         } // isDstOperand
4686
4687         void execute(GPUDynInstPtr) override;
4688     }; // Inst_SOP1__S_BREV_B32
4689
4690     class Inst_SOP1__S_BREV_B64 : public Inst_SOP1
4691     {
4692       public:
4693         Inst_SOP1__S_BREV_B64(InFmt_SOP1*);
4694         ~Inst_SOP1__S_BREV_B64();
4695
4696         int
4697         getNumOperands() override
4698         {
4699             return numDstRegOperands() + numSrcRegOperands();
4700         } // getNumOperands
4701
4702         int numDstRegOperands() override { return 1; }
4703         int numSrcRegOperands() override { return 1; }
4704
4705         int
4706         getOperandSize(int opIdx) override
4707         {
4708             switch (opIdx) {
4709               case 0: //ssrc
4710                 return 8;
4711               case 1: //sdst
4712                 return 8;
4713               default:
4714                 fatal("op idx %i out of bounds\n", opIdx);
4715                 return -1;
4716             }
4717         } // getOperandSize
4718
4719         bool
4720         isSrcOperand(int opIdx) override
4721         {
4722             switch (opIdx) {
4723               case 0: //ssrc
4724                 return true;
4725               case 1: //sdst
4726                 return false;
4727               default:
4728                 fatal("op idx %i out of bounds\n", opIdx);
4729                 return false;
4730             }
4731         } // isSrcOperand
4732
4733         bool
4734         isDstOperand(int opIdx) override
4735         {
4736             switch (opIdx) {
4737               case 0: //ssrc
4738                 return false;
4739               case 1: //sdst
4740                 return true;
4741               default:
4742                 fatal("op idx %i out of bounds\n", opIdx);
4743                 return false;
4744             }
4745         } // isDstOperand
4746
4747         void execute(GPUDynInstPtr) override;
4748     }; // Inst_SOP1__S_BREV_B64
4749
4750     class Inst_SOP1__S_BCNT0_I32_B32 : public Inst_SOP1
4751     {
4752       public:
4753         Inst_SOP1__S_BCNT0_I32_B32(InFmt_SOP1*);
4754         ~Inst_SOP1__S_BCNT0_I32_B32();
4755
4756         int
4757         getNumOperands() override
4758         {
4759             return numDstRegOperands() + numSrcRegOperands();
4760         } // getNumOperands
4761
4762         int numDstRegOperands() override { return 1; }
4763         int numSrcRegOperands() override { return 1; }
4764
4765         int
4766         getOperandSize(int opIdx) override
4767         {
4768             switch (opIdx) {
4769               case 0: //ssrc
4770                 return 4;
4771               case 1: //sdst
4772                 return 4;
4773               default:
4774                 fatal("op idx %i out of bounds\n", opIdx);
4775                 return -1;
4776             }
4777         } // getOperandSize
4778
4779         bool
4780         isSrcOperand(int opIdx) override
4781         {
4782             switch (opIdx) {
4783               case 0: //ssrc
4784                 return true;
4785               case 1: //sdst
4786                 return false;
4787               default:
4788                 fatal("op idx %i out of bounds\n", opIdx);
4789                 return false;
4790             }
4791         } // isSrcOperand
4792
4793         bool
4794         isDstOperand(int opIdx) override
4795         {
4796             switch (opIdx) {
4797               case 0: //ssrc
4798                 return false;
4799               case 1: //sdst
4800                 return true;
4801               default:
4802                 fatal("op idx %i out of bounds\n", opIdx);
4803                 return false;
4804             }
4805         } // isDstOperand
4806
4807         void execute(GPUDynInstPtr) override;
4808     }; // Inst_SOP1__S_BCNT0_I32_B32
4809
4810     class Inst_SOP1__S_BCNT0_I32_B64 : public Inst_SOP1
4811     {
4812       public:
4813         Inst_SOP1__S_BCNT0_I32_B64(InFmt_SOP1*);
4814         ~Inst_SOP1__S_BCNT0_I32_B64();
4815
4816         int
4817         getNumOperands() override
4818         {
4819             return numDstRegOperands() + numSrcRegOperands();
4820         } // getNumOperands
4821
4822         int numDstRegOperands() override { return 1; }
4823         int numSrcRegOperands() override { return 1; }
4824
4825         int
4826         getOperandSize(int opIdx) override
4827         {
4828             switch (opIdx) {
4829               case 0: //ssrc
4830                 return 8;
4831               case 1: //sdst
4832                 return 4;
4833               default:
4834                 fatal("op idx %i out of bounds\n", opIdx);
4835                 return -1;
4836             }
4837         } // getOperandSize
4838
4839         bool
4840         isSrcOperand(int opIdx) override
4841         {
4842             switch (opIdx) {
4843               case 0: //ssrc
4844                 return true;
4845               case 1: //sdst
4846                 return false;
4847               default:
4848                 fatal("op idx %i out of bounds\n", opIdx);
4849                 return false;
4850             }
4851         } // isSrcOperand
4852
4853         bool
4854         isDstOperand(int opIdx) override
4855         {
4856             switch (opIdx) {
4857               case 0: //ssrc
4858                 return false;
4859               case 1: //sdst
4860                 return true;
4861               default:
4862                 fatal("op idx %i out of bounds\n", opIdx);
4863                 return false;
4864             }
4865         } // isDstOperand
4866
4867         void execute(GPUDynInstPtr) override;
4868     }; // Inst_SOP1__S_BCNT0_I32_B64
4869
4870     class Inst_SOP1__S_BCNT1_I32_B32 : public Inst_SOP1
4871     {
4872       public:
4873         Inst_SOP1__S_BCNT1_I32_B32(InFmt_SOP1*);
4874         ~Inst_SOP1__S_BCNT1_I32_B32();
4875
4876         int
4877         getNumOperands() override
4878         {
4879             return numDstRegOperands() + numSrcRegOperands();
4880         } // getNumOperands
4881
4882         int numDstRegOperands() override { return 1; }
4883         int numSrcRegOperands() override { return 1; }
4884
4885         int
4886         getOperandSize(int opIdx) override
4887         {
4888             switch (opIdx) {
4889               case 0: //ssrc
4890                 return 4;
4891               case 1: //sdst
4892                 return 4;
4893               default:
4894                 fatal("op idx %i out of bounds\n", opIdx);
4895                 return -1;
4896             }
4897         } // getOperandSize
4898
4899         bool
4900         isSrcOperand(int opIdx) override
4901         {
4902             switch (opIdx) {
4903               case 0: //ssrc
4904                 return true;
4905               case 1: //sdst
4906                 return false;
4907               default:
4908                 fatal("op idx %i out of bounds\n", opIdx);
4909                 return false;
4910             }
4911         } // isSrcOperand
4912
4913         bool
4914         isDstOperand(int opIdx) override
4915         {
4916             switch (opIdx) {
4917               case 0: //ssrc
4918                 return false;
4919               case 1: //sdst
4920                 return true;
4921               default:
4922                 fatal("op idx %i out of bounds\n", opIdx);
4923                 return false;
4924             }
4925         } // isDstOperand
4926
4927         void execute(GPUDynInstPtr) override;
4928     }; // Inst_SOP1__S_BCNT1_I32_B32
4929
4930     class Inst_SOP1__S_BCNT1_I32_B64 : public Inst_SOP1
4931     {
4932       public:
4933         Inst_SOP1__S_BCNT1_I32_B64(InFmt_SOP1*);
4934         ~Inst_SOP1__S_BCNT1_I32_B64();
4935
4936         int
4937         getNumOperands() override
4938         {
4939             return numDstRegOperands() + numSrcRegOperands();
4940         } // getNumOperands
4941
4942         int numDstRegOperands() override { return 1; }
4943         int numSrcRegOperands() override { return 1; }
4944
4945         int
4946         getOperandSize(int opIdx) override
4947         {
4948             switch (opIdx) {
4949               case 0: //ssrc
4950                 return 8;
4951               case 1: //sdst
4952                 return 4;
4953               default:
4954                 fatal("op idx %i out of bounds\n", opIdx);
4955                 return -1;
4956             }
4957         } // getOperandSize
4958
4959         bool
4960         isSrcOperand(int opIdx) override
4961         {
4962             switch (opIdx) {
4963               case 0: //ssrc
4964                 return true;
4965               case 1: //sdst
4966                 return false;
4967               default:
4968                 fatal("op idx %i out of bounds\n", opIdx);
4969                 return false;
4970             }
4971         } // isSrcOperand
4972
4973         bool
4974         isDstOperand(int opIdx) override
4975         {
4976             switch (opIdx) {
4977               case 0: //ssrc
4978                 return false;
4979               case 1: //sdst
4980                 return true;
4981               default:
4982                 fatal("op idx %i out of bounds\n", opIdx);
4983                 return false;
4984             }
4985         } // isDstOperand
4986
4987         void execute(GPUDynInstPtr) override;
4988     }; // Inst_SOP1__S_BCNT1_I32_B64
4989
4990     class Inst_SOP1__S_FF0_I32_B32 : public Inst_SOP1
4991     {
4992       public:
4993         Inst_SOP1__S_FF0_I32_B32(InFmt_SOP1*);
4994         ~Inst_SOP1__S_FF0_I32_B32();
4995
4996         int
4997         getNumOperands() override
4998         {
4999             return numDstRegOperands() + numSrcRegOperands();
5000         } // getNumOperands
5001
5002         int numDstRegOperands() override { return 1; }
5003         int numSrcRegOperands() override { return 1; }
5004
5005         int
5006         getOperandSize(int opIdx) override
5007         {
5008             switch (opIdx) {
5009               case 0: //ssrc
5010                 return 4;
5011               case 1: //sdst
5012                 return 4;
5013               default:
5014                 fatal("op idx %i out of bounds\n", opIdx);
5015                 return -1;
5016             }
5017         } // getOperandSize
5018
5019         bool
5020         isSrcOperand(int opIdx) override
5021         {
5022             switch (opIdx) {
5023               case 0: //ssrc
5024                 return true;
5025               case 1: //sdst
5026                 return false;
5027               default:
5028                 fatal("op idx %i out of bounds\n", opIdx);
5029                 return false;
5030             }
5031         } // isSrcOperand
5032
5033         bool
5034         isDstOperand(int opIdx) override
5035         {
5036             switch (opIdx) {
5037               case 0: //ssrc
5038                 return false;
5039               case 1: //sdst
5040                 return true;
5041               default:
5042                 fatal("op idx %i out of bounds\n", opIdx);
5043                 return false;
5044             }
5045         } // isDstOperand
5046
5047         void execute(GPUDynInstPtr) override;
5048     }; // Inst_SOP1__S_FF0_I32_B32
5049
5050     class Inst_SOP1__S_FF0_I32_B64 : public Inst_SOP1
5051     {
5052       public:
5053         Inst_SOP1__S_FF0_I32_B64(InFmt_SOP1*);
5054         ~Inst_SOP1__S_FF0_I32_B64();
5055
5056         int
5057         getNumOperands() override
5058         {
5059             return numDstRegOperands() + numSrcRegOperands();
5060         } // getNumOperands
5061
5062         int numDstRegOperands() override { return 1; }
5063         int numSrcRegOperands() override { return 1; }
5064
5065         int
5066         getOperandSize(int opIdx) override
5067         {
5068             switch (opIdx) {
5069               case 0: //ssrc
5070                 return 8;
5071               case 1: //sdst
5072                 return 4;
5073               default:
5074                 fatal("op idx %i out of bounds\n", opIdx);
5075                 return -1;
5076             }
5077         } // getOperandSize
5078
5079         bool
5080         isSrcOperand(int opIdx) override
5081         {
5082             switch (opIdx) {
5083               case 0: //ssrc
5084                 return true;
5085               case 1: //sdst
5086                 return false;
5087               default:
5088                 fatal("op idx %i out of bounds\n", opIdx);
5089                 return false;
5090             }
5091         } // isSrcOperand
5092
5093         bool
5094         isDstOperand(int opIdx) override
5095         {
5096             switch (opIdx) {
5097               case 0: //ssrc
5098                 return false;
5099               case 1: //sdst
5100                 return true;
5101               default:
5102                 fatal("op idx %i out of bounds\n", opIdx);
5103                 return false;
5104             }
5105         } // isDstOperand
5106
5107         void execute(GPUDynInstPtr) override;
5108     }; // Inst_SOP1__S_FF0_I32_B64
5109
5110     class Inst_SOP1__S_FF1_I32_B32 : public Inst_SOP1
5111     {
5112       public:
5113         Inst_SOP1__S_FF1_I32_B32(InFmt_SOP1*);
5114         ~Inst_SOP1__S_FF1_I32_B32();
5115
5116         int
5117         getNumOperands() override
5118         {
5119             return numDstRegOperands() + numSrcRegOperands();
5120         } // getNumOperands
5121
5122         int numDstRegOperands() override { return 1; }
5123         int numSrcRegOperands() override { return 1; }
5124
5125         int
5126         getOperandSize(int opIdx) override
5127         {
5128             switch (opIdx) {
5129               case 0: //ssrc
5130                 return 4;
5131               case 1: //sdst
5132                 return 4;
5133               default:
5134                 fatal("op idx %i out of bounds\n", opIdx);
5135                 return -1;
5136             }
5137         } // getOperandSize
5138
5139         bool
5140         isSrcOperand(int opIdx) override
5141         {
5142             switch (opIdx) {
5143               case 0: //ssrc
5144                 return true;
5145               case 1: //sdst
5146                 return false;
5147               default:
5148                 fatal("op idx %i out of bounds\n", opIdx);
5149                 return false;
5150             }
5151         } // isSrcOperand
5152
5153         bool
5154         isDstOperand(int opIdx) override
5155         {
5156             switch (opIdx) {
5157               case 0: //ssrc
5158                 return false;
5159               case 1: //sdst
5160                 return true;
5161               default:
5162                 fatal("op idx %i out of bounds\n", opIdx);
5163                 return false;
5164             }
5165         } // isDstOperand
5166
5167         void execute(GPUDynInstPtr) override;
5168     }; // Inst_SOP1__S_FF1_I32_B32
5169
5170     class Inst_SOP1__S_FF1_I32_B64 : public Inst_SOP1
5171     {
5172       public:
5173         Inst_SOP1__S_FF1_I32_B64(InFmt_SOP1*);
5174         ~Inst_SOP1__S_FF1_I32_B64();
5175
5176         int
5177         getNumOperands() override
5178         {
5179             return numDstRegOperands() + numSrcRegOperands();
5180         } // getNumOperands
5181
5182         int numDstRegOperands() override { return 1; }
5183         int numSrcRegOperands() override { return 1; }
5184
5185         int
5186         getOperandSize(int opIdx) override
5187         {
5188             switch (opIdx) {
5189               case 0: //ssrc
5190                 return 8;
5191               case 1: //sdst
5192                 return 4;
5193               default:
5194                 fatal("op idx %i out of bounds\n", opIdx);
5195                 return -1;
5196             }
5197         } // getOperandSize
5198
5199         bool
5200         isSrcOperand(int opIdx) override
5201         {
5202             switch (opIdx) {
5203               case 0: //ssrc
5204                 return true;
5205               case 1: //sdst
5206                 return false;
5207               default:
5208                 fatal("op idx %i out of bounds\n", opIdx);
5209                 return false;
5210             }
5211         } // isSrcOperand
5212
5213         bool
5214         isDstOperand(int opIdx) override
5215         {
5216             switch (opIdx) {
5217               case 0: //ssrc
5218                 return false;
5219               case 1: //sdst
5220                 return true;
5221               default:
5222                 fatal("op idx %i out of bounds\n", opIdx);
5223                 return false;
5224             }
5225         } // isDstOperand
5226
5227         void execute(GPUDynInstPtr) override;
5228     }; // Inst_SOP1__S_FF1_I32_B64
5229
5230     class Inst_SOP1__S_FLBIT_I32_B32 : public Inst_SOP1
5231     {
5232       public:
5233         Inst_SOP1__S_FLBIT_I32_B32(InFmt_SOP1*);
5234         ~Inst_SOP1__S_FLBIT_I32_B32();
5235
5236         int
5237         getNumOperands() override
5238         {
5239             return numDstRegOperands() + numSrcRegOperands();
5240         } // getNumOperands
5241
5242         int numDstRegOperands() override { return 1; }
5243         int numSrcRegOperands() override { return 1; }
5244
5245         int
5246         getOperandSize(int opIdx) override
5247         {
5248             switch (opIdx) {
5249               case 0: //ssrc
5250                 return 4;
5251               case 1: //sdst
5252                 return 4;
5253               default:
5254                 fatal("op idx %i out of bounds\n", opIdx);
5255                 return -1;
5256             }
5257         } // getOperandSize
5258
5259         bool
5260         isSrcOperand(int opIdx) override
5261         {
5262             switch (opIdx) {
5263               case 0: //ssrc
5264                 return true;
5265               case 1: //sdst
5266                 return false;
5267               default:
5268                 fatal("op idx %i out of bounds\n", opIdx);
5269                 return false;
5270             }
5271         } // isSrcOperand
5272
5273         bool
5274         isDstOperand(int opIdx) override
5275         {
5276             switch (opIdx) {
5277               case 0: //ssrc
5278                 return false;
5279               case 1: //sdst
5280                 return true;
5281               default:
5282                 fatal("op idx %i out of bounds\n", opIdx);
5283                 return false;
5284             }
5285         } // isDstOperand
5286
5287         void execute(GPUDynInstPtr) override;
5288     }; // Inst_SOP1__S_FLBIT_I32_B32
5289
5290     class Inst_SOP1__S_FLBIT_I32_B64 : public Inst_SOP1
5291     {
5292       public:
5293         Inst_SOP1__S_FLBIT_I32_B64(InFmt_SOP1*);
5294         ~Inst_SOP1__S_FLBIT_I32_B64();
5295
5296         int
5297         getNumOperands() override
5298         {
5299             return numDstRegOperands() + numSrcRegOperands();
5300         } // getNumOperands
5301
5302         int numDstRegOperands() override { return 1; }
5303         int numSrcRegOperands() override { return 1; }
5304
5305         int
5306         getOperandSize(int opIdx) override
5307         {
5308             switch (opIdx) {
5309               case 0: //ssrc
5310                 return 8;
5311               case 1: //sdst
5312                 return 4;
5313               default:
5314                 fatal("op idx %i out of bounds\n", opIdx);
5315                 return -1;
5316             }
5317         } // getOperandSize
5318
5319         bool
5320         isSrcOperand(int opIdx) override
5321         {
5322             switch (opIdx) {
5323               case 0: //ssrc
5324                 return true;
5325               case 1: //sdst
5326                 return false;
5327               default:
5328                 fatal("op idx %i out of bounds\n", opIdx);
5329                 return false;
5330             }
5331         } // isSrcOperand
5332
5333         bool
5334         isDstOperand(int opIdx) override
5335         {
5336             switch (opIdx) {
5337               case 0: //ssrc
5338                 return false;
5339               case 1: //sdst
5340                 return true;
5341               default:
5342                 fatal("op idx %i out of bounds\n", opIdx);
5343                 return false;
5344             }
5345         } // isDstOperand
5346
5347         void execute(GPUDynInstPtr) override;
5348     }; // Inst_SOP1__S_FLBIT_I32_B64
5349
5350     class Inst_SOP1__S_FLBIT_I32 : public Inst_SOP1
5351     {
5352       public:
5353         Inst_SOP1__S_FLBIT_I32(InFmt_SOP1*);
5354         ~Inst_SOP1__S_FLBIT_I32();
5355
5356         int
5357         getNumOperands() override
5358         {
5359             return numDstRegOperands() + numSrcRegOperands();
5360         } // getNumOperands
5361
5362         int numDstRegOperands() override { return 1; }
5363         int numSrcRegOperands() override { return 1; }
5364
5365         int
5366         getOperandSize(int opIdx) override
5367         {
5368             switch (opIdx) {
5369               case 0: //ssrc
5370                 return 4;
5371               case 1: //sdst
5372                 return 4;
5373               default:
5374                 fatal("op idx %i out of bounds\n", opIdx);
5375                 return -1;
5376             }
5377         } // getOperandSize
5378
5379         bool
5380         isSrcOperand(int opIdx) override
5381         {
5382             switch (opIdx) {
5383               case 0: //ssrc
5384                 return true;
5385               case 1: //sdst
5386                 return false;
5387               default:
5388                 fatal("op idx %i out of bounds\n", opIdx);
5389                 return false;
5390             }
5391         } // isSrcOperand
5392
5393         bool
5394         isDstOperand(int opIdx) override
5395         {
5396             switch (opIdx) {
5397               case 0: //ssrc
5398                 return false;
5399               case 1: //sdst
5400                 return true;
5401               default:
5402                 fatal("op idx %i out of bounds\n", opIdx);
5403                 return false;
5404             }
5405         } // isDstOperand
5406
5407         void execute(GPUDynInstPtr) override;
5408     }; // Inst_SOP1__S_FLBIT_I32
5409
5410     class Inst_SOP1__S_FLBIT_I32_I64 : public Inst_SOP1
5411     {
5412       public:
5413         Inst_SOP1__S_FLBIT_I32_I64(InFmt_SOP1*);
5414         ~Inst_SOP1__S_FLBIT_I32_I64();
5415
5416         int
5417         getNumOperands() override
5418         {
5419             return numDstRegOperands() + numSrcRegOperands();
5420         } // getNumOperands
5421
5422         int numDstRegOperands() override { return 1; }
5423         int numSrcRegOperands() override { return 1; }
5424
5425         int
5426         getOperandSize(int opIdx) override
5427         {
5428             switch (opIdx) {
5429               case 0: //ssrc
5430                 return 8;
5431               case 1: //sdst
5432                 return 4;
5433               default:
5434                 fatal("op idx %i out of bounds\n", opIdx);
5435                 return -1;
5436             }
5437         } // getOperandSize
5438
5439         bool
5440         isSrcOperand(int opIdx) override
5441         {
5442             switch (opIdx) {
5443               case 0: //ssrc
5444                 return true;
5445               case 1: //sdst
5446                 return false;
5447               default:
5448                 fatal("op idx %i out of bounds\n", opIdx);
5449                 return false;
5450             }
5451         } // isSrcOperand
5452
5453         bool
5454         isDstOperand(int opIdx) override
5455         {
5456             switch (opIdx) {
5457               case 0: //ssrc
5458                 return false;
5459               case 1: //sdst
5460                 return true;
5461               default:
5462                 fatal("op idx %i out of bounds\n", opIdx);
5463                 return false;
5464             }
5465         } // isDstOperand
5466
5467         void execute(GPUDynInstPtr) override;
5468     }; // Inst_SOP1__S_FLBIT_I32_I64
5469
5470     class Inst_SOP1__S_SEXT_I32_I8 : public Inst_SOP1
5471     {
5472       public:
5473         Inst_SOP1__S_SEXT_I32_I8(InFmt_SOP1*);
5474         ~Inst_SOP1__S_SEXT_I32_I8();
5475
5476         int
5477         getNumOperands() override
5478         {
5479             return numDstRegOperands() + numSrcRegOperands();
5480         } // getNumOperands
5481
5482         int numDstRegOperands() override { return 1; }
5483         int numSrcRegOperands() override { return 1; }
5484
5485         int
5486         getOperandSize(int opIdx) override
5487         {
5488             switch (opIdx) {
5489               case 0: //ssrc
5490                 return 4;
5491               case 1: //sdst
5492                 return 4;
5493               default:
5494                 fatal("op idx %i out of bounds\n", opIdx);
5495                 return -1;
5496             }
5497         } // getOperandSize
5498
5499         bool
5500         isSrcOperand(int opIdx) override
5501         {
5502             switch (opIdx) {
5503               case 0: //ssrc
5504                 return true;
5505               case 1: //sdst
5506                 return false;
5507               default:
5508                 fatal("op idx %i out of bounds\n", opIdx);
5509                 return false;
5510             }
5511         } // isSrcOperand
5512
5513         bool
5514         isDstOperand(int opIdx) override
5515         {
5516             switch (opIdx) {
5517               case 0: //ssrc
5518                 return false;
5519               case 1: //sdst
5520                 return true;
5521               default:
5522                 fatal("op idx %i out of bounds\n", opIdx);
5523                 return false;
5524             }
5525         } // isDstOperand
5526
5527         void execute(GPUDynInstPtr) override;
5528     }; // Inst_SOP1__S_SEXT_I32_I8
5529
5530     class Inst_SOP1__S_SEXT_I32_I16 : public Inst_SOP1
5531     {
5532       public:
5533         Inst_SOP1__S_SEXT_I32_I16(InFmt_SOP1*);
5534         ~Inst_SOP1__S_SEXT_I32_I16();
5535
5536         int
5537         getNumOperands() override
5538         {
5539             return numDstRegOperands() + numSrcRegOperands();
5540         } // getNumOperands
5541
5542         int numDstRegOperands() override { return 1; }
5543         int numSrcRegOperands() override { return 1; }
5544
5545         int
5546         getOperandSize(int opIdx) override
5547         {
5548             switch (opIdx) {
5549               case 0: //ssrc
5550                 return 4;
5551               case 1: //sdst
5552                 return 4;
5553               default:
5554                 fatal("op idx %i out of bounds\n", opIdx);
5555                 return -1;
5556             }
5557         } // getOperandSize
5558
5559         bool
5560         isSrcOperand(int opIdx) override
5561         {
5562             switch (opIdx) {
5563               case 0: //ssrc
5564                 return true;
5565               case 1: //sdst
5566                 return false;
5567               default:
5568                 fatal("op idx %i out of bounds\n", opIdx);
5569                 return false;
5570             }
5571         } // isSrcOperand
5572
5573         bool
5574         isDstOperand(int opIdx) override
5575         {
5576             switch (opIdx) {
5577               case 0: //ssrc
5578                 return false;
5579               case 1: //sdst
5580                 return true;
5581               default:
5582                 fatal("op idx %i out of bounds\n", opIdx);
5583                 return false;
5584             }
5585         } // isDstOperand
5586
5587         void execute(GPUDynInstPtr) override;
5588     }; // Inst_SOP1__S_SEXT_I32_I16
5589
5590     class Inst_SOP1__S_BITSET0_B32 : public Inst_SOP1
5591     {
5592       public:
5593         Inst_SOP1__S_BITSET0_B32(InFmt_SOP1*);
5594         ~Inst_SOP1__S_BITSET0_B32();
5595
5596         int
5597         getNumOperands() override
5598         {
5599             return numDstRegOperands() + numSrcRegOperands();
5600         } // getNumOperands
5601
5602         int numDstRegOperands() override { return 1; }
5603         int numSrcRegOperands() override { return 1; }
5604
5605         int
5606         getOperandSize(int opIdx) override
5607         {
5608             switch (opIdx) {
5609               case 0: //ssrc
5610                 return 4;
5611               case 1: //sdst
5612                 return 4;
5613               default:
5614                 fatal("op idx %i out of bounds\n", opIdx);
5615                 return -1;
5616             }
5617         } // getOperandSize
5618
5619         bool
5620         isSrcOperand(int opIdx) override
5621         {
5622             switch (opIdx) {
5623               case 0: //ssrc
5624                 return true;
5625               case 1: //sdst
5626                 return false;
5627               default:
5628                 fatal("op idx %i out of bounds\n", opIdx);
5629                 return false;
5630             }
5631         } // isSrcOperand
5632
5633         bool
5634         isDstOperand(int opIdx) override
5635         {
5636             switch (opIdx) {
5637               case 0: //ssrc
5638                 return false;
5639               case 1: //sdst
5640                 return true;
5641               default:
5642                 fatal("op idx %i out of bounds\n", opIdx);
5643                 return false;
5644             }
5645         } // isDstOperand
5646
5647         void execute(GPUDynInstPtr) override;
5648     }; // Inst_SOP1__S_BITSET0_B32
5649
5650     class Inst_SOP1__S_BITSET0_B64 : public Inst_SOP1
5651     {
5652       public:
5653         Inst_SOP1__S_BITSET0_B64(InFmt_SOP1*);
5654         ~Inst_SOP1__S_BITSET0_B64();
5655
5656         int
5657         getNumOperands() override
5658         {
5659             return numDstRegOperands() + numSrcRegOperands();
5660         } // getNumOperands
5661
5662         int numDstRegOperands() override { return 1; }
5663         int numSrcRegOperands() override { return 1; }
5664
5665         int
5666         getOperandSize(int opIdx) override
5667         {
5668             switch (opIdx) {
5669               case 0: //ssrc
5670                 return 4;
5671               case 1: //sdst
5672                 return 8;
5673               default:
5674                 fatal("op idx %i out of bounds\n", opIdx);
5675                 return -1;
5676             }
5677         } // getOperandSize
5678
5679         bool
5680         isSrcOperand(int opIdx) override
5681         {
5682             switch (opIdx) {
5683               case 0: //ssrc
5684                 return true;
5685               case 1: //sdst
5686                 return false;
5687               default:
5688                 fatal("op idx %i out of bounds\n", opIdx);
5689                 return false;
5690             }
5691         } // isSrcOperand
5692
5693         bool
5694         isDstOperand(int opIdx) override
5695         {
5696             switch (opIdx) {
5697               case 0: //ssrc
5698                 return false;
5699               case 1: //sdst
5700                 return true;
5701               default:
5702                 fatal("op idx %i out of bounds\n", opIdx);
5703                 return false;
5704             }
5705         } // isDstOperand
5706
5707         void execute(GPUDynInstPtr) override;
5708     }; // Inst_SOP1__S_BITSET0_B64
5709
5710     class Inst_SOP1__S_BITSET1_B32 : public Inst_SOP1
5711     {
5712       public:
5713         Inst_SOP1__S_BITSET1_B32(InFmt_SOP1*);
5714         ~Inst_SOP1__S_BITSET1_B32();
5715
5716         int
5717         getNumOperands() override
5718         {
5719             return numDstRegOperands() + numSrcRegOperands();
5720         } // getNumOperands
5721
5722         int numDstRegOperands() override { return 1; }
5723         int numSrcRegOperands() override { return 1; }
5724
5725         int
5726         getOperandSize(int opIdx) override
5727         {
5728             switch (opIdx) {
5729               case 0: //ssrc
5730                 return 4;
5731               case 1: //sdst
5732                 return 4;
5733               default:
5734                 fatal("op idx %i out of bounds\n", opIdx);
5735                 return -1;
5736             }
5737         } // getOperandSize
5738
5739         bool
5740         isSrcOperand(int opIdx) override
5741         {
5742             switch (opIdx) {
5743               case 0: //ssrc
5744                 return true;
5745               case 1: //sdst
5746                 return false;
5747               default:
5748                 fatal("op idx %i out of bounds\n", opIdx);
5749                 return false;
5750             }
5751         } // isSrcOperand
5752
5753         bool
5754         isDstOperand(int opIdx) override
5755         {
5756             switch (opIdx) {
5757               case 0: //ssrc
5758                 return false;
5759               case 1: //sdst
5760                 return true;
5761               default:
5762                 fatal("op idx %i out of bounds\n", opIdx);
5763                 return false;
5764             }
5765         } // isDstOperand
5766
5767         void execute(GPUDynInstPtr) override;
5768     }; // Inst_SOP1__S_BITSET1_B32
5769
5770     class Inst_SOP1__S_BITSET1_B64 : public Inst_SOP1
5771     {
5772       public:
5773         Inst_SOP1__S_BITSET1_B64(InFmt_SOP1*);
5774         ~Inst_SOP1__S_BITSET1_B64();
5775
5776         int
5777         getNumOperands() override
5778         {
5779             return numDstRegOperands() + numSrcRegOperands();
5780         } // getNumOperands
5781
5782         int numDstRegOperands() override { return 1; }
5783         int numSrcRegOperands() override { return 1; }
5784
5785         int
5786         getOperandSize(int opIdx) override
5787         {
5788             switch (opIdx) {
5789               case 0: //ssrc
5790                 return 4;
5791               case 1: //sdst
5792                 return 8;
5793               default:
5794                 fatal("op idx %i out of bounds\n", opIdx);
5795                 return -1;
5796             }
5797         } // getOperandSize
5798
5799         bool
5800         isSrcOperand(int opIdx) override
5801         {
5802             switch (opIdx) {
5803               case 0: //ssrc
5804                 return true;
5805               case 1: //sdst
5806                 return false;
5807               default:
5808                 fatal("op idx %i out of bounds\n", opIdx);
5809                 return false;
5810             }
5811         } // isSrcOperand
5812
5813         bool
5814         isDstOperand(int opIdx) override
5815         {
5816             switch (opIdx) {
5817               case 0: //ssrc
5818                 return false;
5819               case 1: //sdst
5820                 return true;
5821               default:
5822                 fatal("op idx %i out of bounds\n", opIdx);
5823                 return false;
5824             }
5825         } // isDstOperand
5826
5827         void execute(GPUDynInstPtr) override;
5828     }; // Inst_SOP1__S_BITSET1_B64
5829
5830     class Inst_SOP1__S_GETPC_B64 : public Inst_SOP1
5831     {
5832       public:
5833         Inst_SOP1__S_GETPC_B64(InFmt_SOP1*);
5834         ~Inst_SOP1__S_GETPC_B64();
5835
5836         int
5837         getNumOperands() override
5838         {
5839             return numDstRegOperands() + numSrcRegOperands();
5840         } // getNumOperands
5841
5842         int numDstRegOperands() override { return 1; }
5843         int numSrcRegOperands() override { return 0; }
5844
5845         int
5846         getOperandSize(int opIdx) override
5847         {
5848             switch (opIdx) {
5849               case 0: //sdst
5850                 return 8;
5851               default:
5852                 fatal("op idx %i out of bounds\n", opIdx);
5853                 return -1;
5854             }
5855         } // getOperandSize
5856
5857         bool
5858         isSrcOperand(int opIdx) override
5859         {
5860             switch (opIdx) {
5861               case 0: //sdst
5862                 return false;
5863               default:
5864                 fatal("op idx %i out of bounds\n", opIdx);
5865                 return false;
5866             }
5867         } // isSrcOperand
5868
5869         bool
5870         isDstOperand(int opIdx) override
5871         {
5872             switch (opIdx) {
5873               case 0: //sdst
5874                 return true;
5875               default:
5876                 fatal("op idx %i out of bounds\n", opIdx);
5877                 return false;
5878             }
5879         } // isDstOperand
5880
5881         void execute(GPUDynInstPtr) override;
5882     }; // Inst_SOP1__S_GETPC_B64
5883
5884     class Inst_SOP1__S_SETPC_B64 : public Inst_SOP1
5885     {
5886       public:
5887         Inst_SOP1__S_SETPC_B64(InFmt_SOP1*);
5888         ~Inst_SOP1__S_SETPC_B64();
5889
5890         int
5891         getNumOperands() override
5892         {
5893             return numDstRegOperands() + numSrcRegOperands();
5894         } // getNumOperands
5895
5896         int numDstRegOperands() override { return 0; }
5897         int numSrcRegOperands() override { return 1; }
5898
5899         int
5900         getOperandSize(int opIdx) override
5901         {
5902             switch (opIdx) {
5903               case 0: //ssrc
5904                 return 8;
5905               case 1: //sdst
5906                 return 8;
5907               default:
5908                 fatal("op idx %i out of bounds\n", opIdx);
5909                 return -1;
5910             }
5911         } // getOperandSize
5912
5913         bool
5914         isSrcOperand(int opIdx) override
5915         {
5916             switch (opIdx) {
5917               case 0: //ssrc
5918                 return true;
5919               case 1: //sdst
5920                 return false;
5921               default:
5922                 fatal("op idx %i out of bounds\n", opIdx);
5923                 return false;
5924             }
5925         } // isSrcOperand
5926
5927         bool
5928         isDstOperand(int opIdx) override
5929         {
5930             switch (opIdx) {
5931               case 0: //ssrc
5932                 return false;
5933               case 1: //sdst
5934                 return true;
5935               default:
5936                 fatal("op idx %i out of bounds\n", opIdx);
5937                 return false;
5938             }
5939         } // isDstOperand
5940
5941         void execute(GPUDynInstPtr) override;
5942     }; // Inst_SOP1__S_SETPC_B64
5943
5944     class Inst_SOP1__S_SWAPPC_B64 : public Inst_SOP1
5945     {
5946       public:
5947         Inst_SOP1__S_SWAPPC_B64(InFmt_SOP1*);
5948         ~Inst_SOP1__S_SWAPPC_B64();
5949
5950         int
5951         getNumOperands() override
5952         {
5953             return numDstRegOperands() + numSrcRegOperands();
5954         } // getNumOperands
5955
5956         int numDstRegOperands() override { return 1; }
5957         int numSrcRegOperands() override { return 1; }
5958
5959         int
5960         getOperandSize(int opIdx) override
5961         {
5962             switch (opIdx) {
5963               case 0: //ssrc
5964                 return 8;
5965               case 1: //sdst
5966                 return 8;
5967               default:
5968                 fatal("op idx %i out of bounds\n", opIdx);
5969                 return -1;
5970             }
5971         } // getOperandSize
5972
5973         bool
5974         isSrcOperand(int opIdx) override
5975         {
5976             switch (opIdx) {
5977               case 0: //ssrc
5978                 return true;
5979               case 1: //sdst
5980                 return false;
5981               default:
5982                 fatal("op idx %i out of bounds\n", opIdx);
5983                 return false;
5984             }
5985         } // isSrcOperand
5986
5987         bool
5988         isDstOperand(int opIdx) override
5989         {
5990             switch (opIdx) {
5991               case 0: //ssrc
5992                 return false;
5993               case 1: //sdst
5994                 return true;
5995               default:
5996                 fatal("op idx %i out of bounds\n", opIdx);
5997                 return false;
5998             }
5999         } // isDstOperand
6000
6001         void execute(GPUDynInstPtr) override;
6002     }; // Inst_SOP1__S_SWAPPC_B64
6003
6004     class Inst_SOP1__S_RFE_B64 : public Inst_SOP1
6005     {
6006       public:
6007         Inst_SOP1__S_RFE_B64(InFmt_SOP1*);
6008         ~Inst_SOP1__S_RFE_B64();
6009
6010         int
6011         getNumOperands() override
6012         {
6013             return numDstRegOperands() + numSrcRegOperands();
6014         } // getNumOperands
6015
6016         int numDstRegOperands() override { return 0; }
6017         int numSrcRegOperands() override { return 1; }
6018
6019         int
6020         getOperandSize(int opIdx) override
6021         {
6022             switch (opIdx) {
6023               case 0: //ssrc
6024                 return 8;
6025               case 1: //sdst
6026                 return 8;
6027               default:
6028                 fatal("op idx %i out of bounds\n", opIdx);
6029                 return -1;
6030             }
6031         } // getOperandSize
6032
6033         bool
6034         isSrcOperand(int opIdx) override
6035         {
6036             switch (opIdx) {
6037               case 0: //ssrc
6038                 return true;
6039               case 1: //sdst
6040                 return false;
6041               default:
6042                 fatal("op idx %i out of bounds\n", opIdx);
6043                 return false;
6044             }
6045         } // isSrcOperand
6046
6047         bool
6048         isDstOperand(int opIdx) override
6049         {
6050             switch (opIdx) {
6051               case 0: //ssrc
6052                 return false;
6053               case 1: //sdst
6054                 return true;
6055               default:
6056                 fatal("op idx %i out of bounds\n", opIdx);
6057                 return false;
6058             }
6059         } // isDstOperand
6060
6061         void execute(GPUDynInstPtr) override;
6062     }; // Inst_SOP1__S_RFE_B64
6063
6064     class Inst_SOP1__S_AND_SAVEEXEC_B64 : public Inst_SOP1
6065     {
6066       public:
6067         Inst_SOP1__S_AND_SAVEEXEC_B64(InFmt_SOP1*);
6068         ~Inst_SOP1__S_AND_SAVEEXEC_B64();
6069
6070         int
6071         getNumOperands() override
6072         {
6073             return numDstRegOperands() + numSrcRegOperands();
6074         } // getNumOperands
6075
6076         int numDstRegOperands() override { return 1; }
6077         int numSrcRegOperands() override { return 1; }
6078
6079         int
6080         getOperandSize(int opIdx) override
6081         {
6082             switch (opIdx) {
6083               case 0: //ssrc
6084                 return 8;
6085               case 1: //sdst
6086                 return 8;
6087               default:
6088                 fatal("op idx %i out of bounds\n", opIdx);
6089                 return -1;
6090             }
6091         } // getOperandSize
6092
6093         bool
6094         isSrcOperand(int opIdx) override
6095         {
6096             switch (opIdx) {
6097               case 0: //ssrc
6098                 return true;
6099               case 1: //sdst
6100                 return false;
6101               default:
6102                 fatal("op idx %i out of bounds\n", opIdx);
6103                 return false;
6104             }
6105         } // isSrcOperand
6106
6107         bool
6108         isDstOperand(int opIdx) override
6109         {
6110             switch (opIdx) {
6111               case 0: //ssrc
6112                 return false;
6113               case 1: //sdst
6114                 return true;
6115               default:
6116                 fatal("op idx %i out of bounds\n", opIdx);
6117                 return false;
6118             }
6119         } // isDstOperand
6120
6121         void execute(GPUDynInstPtr) override;
6122     }; // Inst_SOP1__S_AND_SAVEEXEC_B64
6123
6124     class Inst_SOP1__S_OR_SAVEEXEC_B64 : public Inst_SOP1
6125     {
6126       public:
6127         Inst_SOP1__S_OR_SAVEEXEC_B64(InFmt_SOP1*);
6128         ~Inst_SOP1__S_OR_SAVEEXEC_B64();
6129
6130         int
6131         getNumOperands() override
6132         {
6133             return numDstRegOperands() + numSrcRegOperands();
6134         } // getNumOperands
6135
6136         int numDstRegOperands() override { return 1; }
6137         int numSrcRegOperands() override { return 1; }
6138
6139         int
6140         getOperandSize(int opIdx) override
6141         {
6142             switch (opIdx) {
6143               case 0: //ssrc
6144                 return 8;
6145               case 1: //sdst
6146                 return 8;
6147               default:
6148                 fatal("op idx %i out of bounds\n", opIdx);
6149                 return -1;
6150             }
6151         } // getOperandSize
6152
6153         bool
6154         isSrcOperand(int opIdx) override
6155         {
6156             switch (opIdx) {
6157               case 0: //ssrc
6158                 return true;
6159               case 1: //sdst
6160                 return false;
6161               default:
6162                 fatal("op idx %i out of bounds\n", opIdx);
6163                 return false;
6164             }
6165         } // isSrcOperand
6166
6167         bool
6168         isDstOperand(int opIdx) override
6169         {
6170             switch (opIdx) {
6171               case 0: //ssrc
6172                 return false;
6173               case 1: //sdst
6174                 return true;
6175               default:
6176                 fatal("op idx %i out of bounds\n", opIdx);
6177                 return false;
6178             }
6179         } // isDstOperand
6180
6181         void execute(GPUDynInstPtr) override;
6182     }; // Inst_SOP1__S_OR_SAVEEXEC_B64
6183
6184     class Inst_SOP1__S_XOR_SAVEEXEC_B64 : public Inst_SOP1
6185     {
6186       public:
6187         Inst_SOP1__S_XOR_SAVEEXEC_B64(InFmt_SOP1*);
6188         ~Inst_SOP1__S_XOR_SAVEEXEC_B64();
6189
6190         int
6191         getNumOperands() override
6192         {
6193             return numDstRegOperands() + numSrcRegOperands();
6194         } // getNumOperands
6195
6196         int numDstRegOperands() override { return 1; }
6197         int numSrcRegOperands() override { return 1; }
6198
6199         int
6200         getOperandSize(int opIdx) override
6201         {
6202             switch (opIdx) {
6203               case 0: //ssrc
6204                 return 8;
6205               case 1: //sdst
6206                 return 8;
6207               default:
6208                 fatal("op idx %i out of bounds\n", opIdx);
6209                 return -1;
6210             }
6211         } // getOperandSize
6212
6213         bool
6214         isSrcOperand(int opIdx) override
6215         {
6216             switch (opIdx) {
6217               case 0: //ssrc
6218                 return true;
6219               case 1: //sdst
6220                 return false;
6221               default:
6222                 fatal("op idx %i out of bounds\n", opIdx);
6223                 return false;
6224             }
6225         } // isSrcOperand
6226
6227         bool
6228         isDstOperand(int opIdx) override
6229         {
6230             switch (opIdx) {
6231               case 0: //ssrc
6232                 return false;
6233               case 1: //sdst
6234                 return true;
6235               default:
6236                 fatal("op idx %i out of bounds\n", opIdx);
6237                 return false;
6238             }
6239         } // isDstOperand
6240
6241         void execute(GPUDynInstPtr) override;
6242     }; // Inst_SOP1__S_XOR_SAVEEXEC_B64
6243
6244     class Inst_SOP1__S_ANDN2_SAVEEXEC_B64 : public Inst_SOP1
6245     {
6246       public:
6247         Inst_SOP1__S_ANDN2_SAVEEXEC_B64(InFmt_SOP1*);
6248         ~Inst_SOP1__S_ANDN2_SAVEEXEC_B64();
6249
6250         int
6251         getNumOperands() override
6252         {
6253             return numDstRegOperands() + numSrcRegOperands();
6254         } // getNumOperands
6255
6256         int numDstRegOperands() override { return 1; }
6257         int numSrcRegOperands() override { return 1; }
6258
6259         int
6260         getOperandSize(int opIdx) override
6261         {
6262             switch (opIdx) {
6263               case 0: //ssrc
6264                 return 8;
6265               case 1: //sdst
6266                 return 8;
6267               default:
6268                 fatal("op idx %i out of bounds\n", opIdx);
6269                 return -1;
6270             }
6271         } // getOperandSize
6272
6273         bool
6274         isSrcOperand(int opIdx) override
6275         {
6276             switch (opIdx) {
6277               case 0: //ssrc
6278                 return true;
6279               case 1: //sdst
6280                 return false;
6281               default:
6282                 fatal("op idx %i out of bounds\n", opIdx);
6283                 return false;
6284             }
6285         } // isSrcOperand
6286
6287         bool
6288         isDstOperand(int opIdx) override
6289         {
6290             switch (opIdx) {
6291               case 0: //ssrc
6292                 return false;
6293               case 1: //sdst
6294                 return true;
6295               default:
6296                 fatal("op idx %i out of bounds\n", opIdx);
6297                 return false;
6298             }
6299         } // isDstOperand
6300
6301         void execute(GPUDynInstPtr) override;
6302     }; // Inst_SOP1__S_ANDN2_SAVEEXEC_B64
6303
6304     class Inst_SOP1__S_ORN2_SAVEEXEC_B64 : public Inst_SOP1
6305     {
6306       public:
6307         Inst_SOP1__S_ORN2_SAVEEXEC_B64(InFmt_SOP1*);
6308         ~Inst_SOP1__S_ORN2_SAVEEXEC_B64();
6309
6310         int
6311         getNumOperands() override
6312         {
6313             return numDstRegOperands() + numSrcRegOperands();
6314         } // getNumOperands
6315
6316         int numDstRegOperands() override { return 1; }
6317         int numSrcRegOperands() override { return 1; }
6318
6319         int
6320         getOperandSize(int opIdx) override
6321         {
6322             switch (opIdx) {
6323               case 0: //ssrc
6324                 return 8;
6325               case 1: //sdst
6326                 return 8;
6327               default:
6328                 fatal("op idx %i out of bounds\n", opIdx);
6329                 return -1;
6330             }
6331         } // getOperandSize
6332
6333         bool
6334         isSrcOperand(int opIdx) override
6335         {
6336             switch (opIdx) {
6337               case 0: //ssrc
6338                 return true;
6339               case 1: //sdst
6340                 return false;
6341               default:
6342                 fatal("op idx %i out of bounds\n", opIdx);
6343                 return false;
6344             }
6345         } // isSrcOperand
6346
6347         bool
6348         isDstOperand(int opIdx) override
6349         {
6350             switch (opIdx) {
6351               case 0: //ssrc
6352                 return false;
6353               case 1: //sdst
6354                 return true;
6355               default:
6356                 fatal("op idx %i out of bounds\n", opIdx);
6357                 return false;
6358             }
6359         } // isDstOperand
6360
6361         void execute(GPUDynInstPtr) override;
6362     }; // Inst_SOP1__S_ORN2_SAVEEXEC_B64
6363
6364     class Inst_SOP1__S_NAND_SAVEEXEC_B64 : public Inst_SOP1
6365     {
6366       public:
6367         Inst_SOP1__S_NAND_SAVEEXEC_B64(InFmt_SOP1*);
6368         ~Inst_SOP1__S_NAND_SAVEEXEC_B64();
6369
6370         int
6371         getNumOperands() override
6372         {
6373             return numDstRegOperands() + numSrcRegOperands();
6374         } // getNumOperands
6375
6376         int numDstRegOperands() override { return 1; }
6377         int numSrcRegOperands() override { return 1; }
6378
6379         int
6380         getOperandSize(int opIdx) override
6381         {
6382             switch (opIdx) {
6383               case 0: //ssrc
6384                 return 8;
6385               case 1: //sdst
6386                 return 8;
6387               default:
6388                 fatal("op idx %i out of bounds\n", opIdx);
6389                 return -1;
6390             }
6391         } // getOperandSize
6392
6393         bool
6394         isSrcOperand(int opIdx) override
6395         {
6396             switch (opIdx) {
6397               case 0: //ssrc
6398                 return true;
6399               case 1: //sdst
6400                 return false;
6401               default:
6402                 fatal("op idx %i out of bounds\n", opIdx);
6403                 return false;
6404             }
6405         } // isSrcOperand
6406
6407         bool
6408         isDstOperand(int opIdx) override
6409         {
6410             switch (opIdx) {
6411               case 0: //ssrc
6412                 return false;
6413               case 1: //sdst
6414                 return true;
6415               default:
6416                 fatal("op idx %i out of bounds\n", opIdx);
6417                 return false;
6418             }
6419         } // isDstOperand
6420
6421         void execute(GPUDynInstPtr) override;
6422     }; // Inst_SOP1__S_NAND_SAVEEXEC_B64
6423
6424     class Inst_SOP1__S_NOR_SAVEEXEC_B64 : public Inst_SOP1
6425     {
6426       public:
6427         Inst_SOP1__S_NOR_SAVEEXEC_B64(InFmt_SOP1*);
6428         ~Inst_SOP1__S_NOR_SAVEEXEC_B64();
6429
6430         int
6431         getNumOperands() override
6432         {
6433             return numDstRegOperands() + numSrcRegOperands();
6434         } // getNumOperands
6435
6436         int numDstRegOperands() override { return 1; }
6437         int numSrcRegOperands() override { return 1; }
6438
6439         int
6440         getOperandSize(int opIdx) override
6441         {
6442             switch (opIdx) {
6443               case 0: //ssrc
6444                 return 8;
6445               case 1: //sdst
6446                 return 8;
6447               default:
6448                 fatal("op idx %i out of bounds\n", opIdx);
6449                 return -1;
6450             }
6451         } // getOperandSize
6452
6453         bool
6454         isSrcOperand(int opIdx) override
6455         {
6456             switch (opIdx) {
6457               case 0: //ssrc
6458                 return true;
6459               case 1: //sdst
6460                 return false;
6461               default:
6462                 fatal("op idx %i out of bounds\n", opIdx);
6463                 return false;
6464             }
6465         } // isSrcOperand
6466
6467         bool
6468         isDstOperand(int opIdx) override
6469         {
6470             switch (opIdx) {
6471               case 0: //ssrc
6472                 return false;
6473               case 1: //sdst
6474                 return true;
6475               default:
6476                 fatal("op idx %i out of bounds\n", opIdx);
6477                 return false;
6478             }
6479         } // isDstOperand
6480
6481         void execute(GPUDynInstPtr) override;
6482     }; // Inst_SOP1__S_NOR_SAVEEXEC_B64
6483
6484     class Inst_SOP1__S_XNOR_SAVEEXEC_B64 : public Inst_SOP1
6485     {
6486       public:
6487         Inst_SOP1__S_XNOR_SAVEEXEC_B64(InFmt_SOP1*);
6488         ~Inst_SOP1__S_XNOR_SAVEEXEC_B64();
6489
6490         int
6491         getNumOperands() override
6492         {
6493             return numDstRegOperands() + numSrcRegOperands();
6494         } // getNumOperands
6495
6496         int numDstRegOperands() override { return 1; }
6497         int numSrcRegOperands() override { return 1; }
6498
6499         int
6500         getOperandSize(int opIdx) override
6501         {
6502             switch (opIdx) {
6503               case 0: //ssrc
6504                 return 8;
6505               case 1: //sdst
6506                 return 8;
6507               default:
6508                 fatal("op idx %i out of bounds\n", opIdx);
6509                 return -1;
6510             }
6511         } // getOperandSize
6512
6513         bool
6514         isSrcOperand(int opIdx) override
6515         {
6516             switch (opIdx) {
6517               case 0: //ssrc
6518                 return true;
6519               case 1: //sdst
6520                 return false;
6521               default:
6522                 fatal("op idx %i out of bounds\n", opIdx);
6523                 return false;
6524             }
6525         } // isSrcOperand
6526
6527         bool
6528         isDstOperand(int opIdx) override
6529         {
6530             switch (opIdx) {
6531               case 0: //ssrc
6532                 return false;
6533               case 1: //sdst
6534                 return true;
6535               default:
6536                 fatal("op idx %i out of bounds\n", opIdx);
6537                 return false;
6538             }
6539         } // isDstOperand
6540
6541         void execute(GPUDynInstPtr) override;
6542     }; // Inst_SOP1__S_XNOR_SAVEEXEC_B64
6543
6544     class Inst_SOP1__S_QUADMASK_B32 : public Inst_SOP1
6545     {
6546       public:
6547         Inst_SOP1__S_QUADMASK_B32(InFmt_SOP1*);
6548         ~Inst_SOP1__S_QUADMASK_B32();
6549
6550         int
6551         getNumOperands() override
6552         {
6553             return numDstRegOperands() + numSrcRegOperands();
6554         } // getNumOperands
6555
6556         int numDstRegOperands() override { return 1; }
6557         int numSrcRegOperands() override { return 1; }
6558
6559         int
6560         getOperandSize(int opIdx) override
6561         {
6562             switch (opIdx) {
6563               case 0: //ssrc
6564                 return 4;
6565               case 1: //sdst
6566                 return 4;
6567               default:
6568                 fatal("op idx %i out of bounds\n", opIdx);
6569                 return -1;
6570             }
6571         } // getOperandSize
6572
6573         bool
6574         isSrcOperand(int opIdx) override
6575         {
6576             switch (opIdx) {
6577               case 0: //ssrc
6578                 return true;
6579               case 1: //sdst
6580                 return false;
6581               default:
6582                 fatal("op idx %i out of bounds\n", opIdx);
6583                 return false;
6584             }
6585         } // isSrcOperand
6586
6587         bool
6588         isDstOperand(int opIdx) override
6589         {
6590             switch (opIdx) {
6591               case 0: //ssrc
6592                 return false;
6593               case 1: //sdst
6594                 return true;
6595               default:
6596                 fatal("op idx %i out of bounds\n", opIdx);
6597                 return false;
6598             }
6599         } // isDstOperand
6600
6601         void execute(GPUDynInstPtr) override;
6602     }; // Inst_SOP1__S_QUADMASK_B32
6603
6604     class Inst_SOP1__S_QUADMASK_B64 : public Inst_SOP1
6605     {
6606       public:
6607         Inst_SOP1__S_QUADMASK_B64(InFmt_SOP1*);
6608         ~Inst_SOP1__S_QUADMASK_B64();
6609
6610         int
6611         getNumOperands() override
6612         {
6613             return numDstRegOperands() + numSrcRegOperands();
6614         } // getNumOperands
6615
6616         int numDstRegOperands() override { return 1; }
6617         int numSrcRegOperands() override { return 1; }
6618
6619         int
6620         getOperandSize(int opIdx) override
6621         {
6622             switch (opIdx) {
6623               case 0: //ssrc
6624                 return 8;
6625               case 1: //sdst
6626                 return 8;
6627               default:
6628                 fatal("op idx %i out of bounds\n", opIdx);
6629                 return -1;
6630             }
6631         } // getOperandSize
6632
6633         bool
6634         isSrcOperand(int opIdx) override
6635         {
6636             switch (opIdx) {
6637               case 0: //ssrc
6638                 return true;
6639               case 1: //sdst
6640                 return false;
6641               default:
6642                 fatal("op idx %i out of bounds\n", opIdx);
6643                 return false;
6644             }
6645         } // isSrcOperand
6646
6647         bool
6648         isDstOperand(int opIdx) override
6649         {
6650             switch (opIdx) {
6651               case 0: //ssrc
6652                 return false;
6653               case 1: //sdst
6654                 return true;
6655               default:
6656                 fatal("op idx %i out of bounds\n", opIdx);
6657                 return false;
6658             }
6659         } // isDstOperand
6660
6661         void execute(GPUDynInstPtr) override;
6662     }; // Inst_SOP1__S_QUADMASK_B64
6663
6664     class Inst_SOP1__S_MOVRELS_B32 : public Inst_SOP1
6665     {
6666       public:
6667         Inst_SOP1__S_MOVRELS_B32(InFmt_SOP1*);
6668         ~Inst_SOP1__S_MOVRELS_B32();
6669
6670         int
6671         getNumOperands() override
6672         {
6673             return numDstRegOperands() + numSrcRegOperands();
6674         } // getNumOperands
6675
6676         int numDstRegOperands() override { return 1; }
6677         int numSrcRegOperands() override { return 1; }
6678
6679         int
6680         getOperandSize(int opIdx) override
6681         {
6682             switch (opIdx) {
6683               case 0: //ssrc
6684                 return 4;
6685               case 1: //sdst
6686                 return 4;
6687               default:
6688                 fatal("op idx %i out of bounds\n", opIdx);
6689                 return -1;
6690             }
6691         } // getOperandSize
6692
6693         bool
6694         isSrcOperand(int opIdx) override
6695         {
6696             switch (opIdx) {
6697               case 0: //ssrc
6698                 return true;
6699               case 1: //sdst
6700                 return false;
6701               default:
6702                 fatal("op idx %i out of bounds\n", opIdx);
6703                 return false;
6704             }
6705         } // isSrcOperand
6706
6707         bool
6708         isDstOperand(int opIdx) override
6709         {
6710             switch (opIdx) {
6711               case 0: //ssrc
6712                 return false;
6713               case 1: //sdst
6714                 return true;
6715               default:
6716                 fatal("op idx %i out of bounds\n", opIdx);
6717                 return false;
6718             }
6719         } // isDstOperand
6720
6721         void execute(GPUDynInstPtr) override;
6722     }; // Inst_SOP1__S_MOVRELS_B32
6723
6724     class Inst_SOP1__S_MOVRELS_B64 : public Inst_SOP1
6725     {
6726       public:
6727         Inst_SOP1__S_MOVRELS_B64(InFmt_SOP1*);
6728         ~Inst_SOP1__S_MOVRELS_B64();
6729
6730         int
6731         getNumOperands() override
6732         {
6733             return numDstRegOperands() + numSrcRegOperands();
6734         } // getNumOperands
6735
6736         int numDstRegOperands() override { return 1; }
6737         int numSrcRegOperands() override { return 1; }
6738
6739         int
6740         getOperandSize(int opIdx) override
6741         {
6742             switch (opIdx) {
6743               case 0: //sdst
6744                 return 8;
6745               case 1: //sdst
6746                 return 8;
6747               default:
6748                 fatal("op idx %i out of bounds\n", opIdx);
6749                 return -1;
6750             }
6751         } // getOperandSize
6752
6753         bool
6754         isSrcOperand(int opIdx) override
6755         {
6756             switch (opIdx) {
6757               case 0: //sdst
6758                 return true;
6759               case 1: //sdst
6760                 return false;
6761               default:
6762                 fatal("op idx %i out of bounds\n", opIdx);
6763                 return false;
6764             }
6765         } // isSrcOperand
6766
6767         bool
6768         isDstOperand(int opIdx) override
6769         {
6770             switch (opIdx) {
6771               case 0: //sdst
6772                 return false;
6773               case 1: //sdst
6774                 return true;
6775               default:
6776                 fatal("op idx %i out of bounds\n", opIdx);
6777                 return false;
6778             }
6779         } // isDstOperand
6780
6781         void execute(GPUDynInstPtr) override;
6782     }; // Inst_SOP1__S_MOVRELS_B64
6783
6784     class Inst_SOP1__S_MOVRELD_B32 : public Inst_SOP1
6785     {
6786       public:
6787         Inst_SOP1__S_MOVRELD_B32(InFmt_SOP1*);
6788         ~Inst_SOP1__S_MOVRELD_B32();
6789
6790         int
6791         getNumOperands() override
6792         {
6793             return numDstRegOperands() + numSrcRegOperands();
6794         } // getNumOperands
6795
6796         int numDstRegOperands() override { return 1; }
6797         int numSrcRegOperands() override { return 1; }
6798
6799         int
6800         getOperandSize(int opIdx) override
6801         {
6802             switch (opIdx) {
6803               case 0: //ssrc
6804                 return 4;
6805               case 1: //sdst
6806                 return 4;
6807               default:
6808                 fatal("op idx %i out of bounds\n", opIdx);
6809                 return -1;
6810             }
6811         } // getOperandSize
6812
6813         bool
6814         isSrcOperand(int opIdx) override
6815         {
6816             switch (opIdx) {
6817               case 0: //ssrc
6818                 return true;
6819               case 1: //sdst
6820                 return false;
6821               default:
6822                 fatal("op idx %i out of bounds\n", opIdx);
6823                 return false;
6824             }
6825         } // isSrcOperand
6826
6827         bool
6828         isDstOperand(int opIdx) override
6829         {
6830             switch (opIdx) {
6831               case 0: //ssrc
6832                 return false;
6833               case 1: //sdst
6834                 return true;
6835               default:
6836                 fatal("op idx %i out of bounds\n", opIdx);
6837                 return false;
6838             }
6839         } // isDstOperand
6840
6841         void execute(GPUDynInstPtr) override;
6842     }; // Inst_SOP1__S_MOVRELD_B32
6843
6844     class Inst_SOP1__S_MOVRELD_B64 : public Inst_SOP1
6845     {
6846       public:
6847         Inst_SOP1__S_MOVRELD_B64(InFmt_SOP1*);
6848         ~Inst_SOP1__S_MOVRELD_B64();
6849
6850         int
6851         getNumOperands() override
6852         {
6853             return numDstRegOperands() + numSrcRegOperands();
6854         } // getNumOperands
6855
6856         int numDstRegOperands() override { return 1; }
6857         int numSrcRegOperands() override { return 1; }
6858
6859         int
6860         getOperandSize(int opIdx) override
6861         {
6862             switch (opIdx) {
6863               case 0: //ssrc
6864                 return 8;
6865               case 1: //sdst
6866                 return 8;
6867               default:
6868                 fatal("op idx %i out of bounds\n", opIdx);
6869                 return -1;
6870             }
6871         } // getOperandSize
6872
6873         bool
6874         isSrcOperand(int opIdx) override
6875         {
6876             switch (opIdx) {
6877               case 0: //ssrc
6878                 return true;
6879               case 1: //sdst
6880                 return false;
6881               default:
6882                 fatal("op idx %i out of bounds\n", opIdx);
6883                 return false;
6884             }
6885         } // isSrcOperand
6886
6887         bool
6888         isDstOperand(int opIdx) override
6889         {
6890             switch (opIdx) {
6891               case 0: //ssrc
6892                 return false;
6893               case 1: //sdst
6894                 return true;
6895               default:
6896                 fatal("op idx %i out of bounds\n", opIdx);
6897                 return false;
6898             }
6899         } // isDstOperand
6900
6901         void execute(GPUDynInstPtr) override;
6902     }; // Inst_SOP1__S_MOVRELD_B64
6903
6904     class Inst_SOP1__S_CBRANCH_JOIN : public Inst_SOP1
6905     {
6906       public:
6907         Inst_SOP1__S_CBRANCH_JOIN(InFmt_SOP1*);
6908         ~Inst_SOP1__S_CBRANCH_JOIN();
6909
6910         int
6911         getNumOperands() override
6912         {
6913             return numDstRegOperands() + numSrcRegOperands();
6914         } // getNumOperands
6915
6916         int numDstRegOperands() override { return 0; }
6917         int numSrcRegOperands() override { return 1; }
6918
6919         int
6920         getOperandSize(int opIdx) override
6921         {
6922             switch (opIdx) {
6923               case 0: //ssrc
6924                 return 4;
6925               case 1: //sdst
6926                 return 4;
6927               default:
6928                 fatal("op idx %i out of bounds\n", opIdx);
6929                 return -1;
6930             }
6931         } // getOperandSize
6932
6933         bool
6934         isSrcOperand(int opIdx) override
6935         {
6936             switch (opIdx) {
6937               case 0: //ssrc
6938                 return true;
6939               case 1: //sdst
6940                 return false;
6941               default:
6942                 fatal("op idx %i out of bounds\n", opIdx);
6943                 return false;
6944             }
6945         } // isSrcOperand
6946
6947         bool
6948         isDstOperand(int opIdx) override
6949         {
6950             switch (opIdx) {
6951               case 0: //ssrc
6952                 return false;
6953               case 1: //sdst
6954                 return true;
6955               default:
6956                 fatal("op idx %i out of bounds\n", opIdx);
6957                 return false;
6958             }
6959         } // isDstOperand
6960
6961         void execute(GPUDynInstPtr) override;
6962     }; // Inst_SOP1__S_CBRANCH_JOIN
6963
6964     class Inst_SOP1__S_ABS_I32 : public Inst_SOP1
6965     {
6966       public:
6967         Inst_SOP1__S_ABS_I32(InFmt_SOP1*);
6968         ~Inst_SOP1__S_ABS_I32();
6969
6970         int
6971         getNumOperands() override
6972         {
6973             return numDstRegOperands() + numSrcRegOperands();
6974         } // getNumOperands
6975
6976         int numDstRegOperands() override { return 1; }
6977         int numSrcRegOperands() override { return 1; }
6978
6979         int
6980         getOperandSize(int opIdx) override
6981         {
6982             switch (opIdx) {
6983               case 0: //ssrc
6984                 return 4;
6985               case 1: //sdst
6986                 return 4;
6987               default:
6988                 fatal("op idx %i out of bounds\n", opIdx);
6989                 return -1;
6990             }
6991         } // getOperandSize
6992
6993         bool
6994         isSrcOperand(int opIdx) override
6995         {
6996             switch (opIdx) {
6997               case 0: //ssrc
6998                 return true;
6999               case 1: //sdst
7000                 return false;
7001               default:
7002                 fatal("op idx %i out of bounds\n", opIdx);
7003                 return false;
7004             }
7005         } // isSrcOperand
7006
7007         bool
7008         isDstOperand(int opIdx) override
7009         {
7010             switch (opIdx) {
7011               case 0: //ssrc
7012                 return false;
7013               case 1: //sdst
7014                 return true;
7015               default:
7016                 fatal("op idx %i out of bounds\n", opIdx);
7017                 return false;
7018             }
7019         } // isDstOperand
7020
7021         void execute(GPUDynInstPtr) override;
7022     }; // Inst_SOP1__S_ABS_I32
7023
7024     class Inst_SOP1__S_MOV_FED_B32 : public Inst_SOP1
7025     {
7026       public:
7027         Inst_SOP1__S_MOV_FED_B32(InFmt_SOP1*);
7028         ~Inst_SOP1__S_MOV_FED_B32();
7029
7030         int
7031         getNumOperands() override
7032         {
7033             return numDstRegOperands() + numSrcRegOperands();
7034         } // getNumOperands
7035
7036         int numDstRegOperands() override { return 1; }
7037         int numSrcRegOperands() override { return 1; }
7038
7039         int
7040         getOperandSize(int opIdx) override
7041         {
7042             switch (opIdx) {
7043               case 0: //ssrc
7044                 return 4;
7045               case 1: //sdst
7046                 return 4;
7047               default:
7048                 fatal("op idx %i out of bounds\n", opIdx);
7049                 return -1;
7050             }
7051         } // getOperandSize
7052
7053         bool
7054         isSrcOperand(int opIdx) override
7055         {
7056             switch (opIdx) {
7057               case 0: //ssrc
7058                 return true;
7059               case 1: //sdst
7060                 return false;
7061               default:
7062                 fatal("op idx %i out of bounds\n", opIdx);
7063                 return false;
7064             }
7065         } // isSrcOperand
7066
7067         bool
7068         isDstOperand(int opIdx) override
7069         {
7070             switch (opIdx) {
7071               case 0: //ssrc
7072                 return false;
7073               case 1: //sdst
7074                 return true;
7075               default:
7076                 fatal("op idx %i out of bounds\n", opIdx);
7077                 return false;
7078             }
7079         } // isDstOperand
7080
7081         void execute(GPUDynInstPtr) override;
7082     }; // Inst_SOP1__S_MOV_FED_B32
7083
7084     class Inst_SOP1__S_SET_GPR_IDX_IDX : public Inst_SOP1
7085     {
7086       public:
7087         Inst_SOP1__S_SET_GPR_IDX_IDX(InFmt_SOP1*);
7088         ~Inst_SOP1__S_SET_GPR_IDX_IDX();
7089
7090         int
7091         getNumOperands() override
7092         {
7093             return numDstRegOperands() + numSrcRegOperands();
7094         } // getNumOperands
7095
7096         int numDstRegOperands() override { return 0; }
7097         int numSrcRegOperands() override { return 1; }
7098
7099         int
7100         getOperandSize(int opIdx) override
7101         {
7102             switch (opIdx) {
7103               case 0: //ssrc
7104                 return 4;
7105               case 1: //sdst
7106                 return 4;
7107               default:
7108                 fatal("op idx %i out of bounds\n", opIdx);
7109                 return -1;
7110             }
7111         } // getOperandSize
7112
7113         bool
7114         isSrcOperand(int opIdx) override
7115         {
7116             switch (opIdx) {
7117               case 0: //ssrc
7118                 return true;
7119               case 1: //sdst
7120                 return false;
7121               default:
7122                 fatal("op idx %i out of bounds\n", opIdx);
7123                 return false;
7124             }
7125         } // isSrcOperand
7126
7127         bool
7128         isDstOperand(int opIdx) override
7129         {
7130             switch (opIdx) {
7131               case 0: //ssrc
7132                 return false;
7133               case 1: //sdst
7134                 return true;
7135               default:
7136                 fatal("op idx %i out of bounds\n", opIdx);
7137                 return false;
7138             }
7139         } // isDstOperand
7140
7141         void execute(GPUDynInstPtr) override;
7142     }; // Inst_SOP1__S_SET_GPR_IDX_IDX
7143
7144     class Inst_SOPC__S_CMP_EQ_I32 : public Inst_SOPC
7145     {
7146       public:
7147         Inst_SOPC__S_CMP_EQ_I32(InFmt_SOPC*);
7148         ~Inst_SOPC__S_CMP_EQ_I32();
7149
7150         int
7151         getNumOperands() override
7152         {
7153             return numDstRegOperands() + numSrcRegOperands();
7154         } // getNumOperands
7155
7156         int numDstRegOperands() override { return 0; }
7157         int numSrcRegOperands() override { return 2; }
7158
7159         int
7160         getOperandSize(int opIdx) override
7161         {
7162             switch (opIdx) {
7163               case 0: //ssrc_0
7164                 return 4;
7165               case 1: //ssrc_1
7166                 return 4;
7167               default:
7168                 fatal("op idx %i out of bounds\n", opIdx);
7169                 return -1;
7170             }
7171         } // getOperandSize
7172
7173         bool
7174         isSrcOperand(int opIdx) override
7175         {
7176             switch (opIdx) {
7177               case 0: //ssrc_0
7178                 return true;
7179               case 1: //ssrc_1
7180                 return true;
7181               default:
7182                 fatal("op idx %i out of bounds\n", opIdx);
7183                 return false;
7184             }
7185         } // isSrcOperand
7186
7187         bool
7188         isDstOperand(int opIdx) override
7189         {
7190             switch (opIdx) {
7191               case 0: //ssrc_0
7192                 return false;
7193               case 1: //ssrc_1
7194                 return false;
7195               default:
7196                 fatal("op idx %i out of bounds\n", opIdx);
7197                 return false;
7198             }
7199         } // isDstOperand
7200
7201         void execute(GPUDynInstPtr) override;
7202     }; // Inst_SOPC__S_CMP_EQ_I32
7203
7204     class Inst_SOPC__S_CMP_LG_I32 : public Inst_SOPC
7205     {
7206       public:
7207         Inst_SOPC__S_CMP_LG_I32(InFmt_SOPC*);
7208         ~Inst_SOPC__S_CMP_LG_I32();
7209
7210         int
7211         getNumOperands() override
7212         {
7213             return numDstRegOperands() + numSrcRegOperands();
7214         } // getNumOperands
7215
7216         int numDstRegOperands() override { return 0; }
7217         int numSrcRegOperands() override { return 2; }
7218
7219         int
7220         getOperandSize(int opIdx) override
7221         {
7222             switch (opIdx) {
7223               case 0: //ssrc_0
7224                 return 4;
7225               case 1: //ssrc_1
7226                 return 4;
7227               default:
7228                 fatal("op idx %i out of bounds\n", opIdx);
7229                 return -1;
7230             }
7231         } // getOperandSize
7232
7233         bool
7234         isSrcOperand(int opIdx) override
7235         {
7236             switch (opIdx) {
7237               case 0: //ssrc_0
7238                 return true;
7239               case 1: //ssrc_1
7240                 return true;
7241               default:
7242                 fatal("op idx %i out of bounds\n", opIdx);
7243                 return false;
7244             }
7245         } // isSrcOperand
7246
7247         bool
7248         isDstOperand(int opIdx) override
7249         {
7250             switch (opIdx) {
7251               case 0: //ssrc_0
7252                 return false;
7253               case 1: //ssrc_1
7254                 return false;
7255               default:
7256                 fatal("op idx %i out of bounds\n", opIdx);
7257                 return false;
7258             }
7259         } // isDstOperand
7260
7261         void execute(GPUDynInstPtr) override;
7262     }; // Inst_SOPC__S_CMP_LG_I32
7263
7264     class Inst_SOPC__S_CMP_GT_I32 : public Inst_SOPC
7265     {
7266       public:
7267         Inst_SOPC__S_CMP_GT_I32(InFmt_SOPC*);
7268         ~Inst_SOPC__S_CMP_GT_I32();
7269
7270         int
7271         getNumOperands() override
7272         {
7273             return numDstRegOperands() + numSrcRegOperands();
7274         } // getNumOperands
7275
7276         int numDstRegOperands() override { return 0; }
7277         int numSrcRegOperands() override { return 2; }
7278
7279         int
7280         getOperandSize(int opIdx) override
7281         {
7282             switch (opIdx) {
7283               case 0: //ssrc_0
7284                 return 4;
7285               case 1: //ssrc_1
7286                 return 4;
7287               default:
7288                 fatal("op idx %i out of bounds\n", opIdx);
7289                 return -1;
7290             }
7291         } // getOperandSize
7292
7293         bool
7294         isSrcOperand(int opIdx) override
7295         {
7296             switch (opIdx) {
7297               case 0: //ssrc_0
7298                 return true;
7299               case 1: //ssrc_1
7300                 return true;
7301               default:
7302                 fatal("op idx %i out of bounds\n", opIdx);
7303                 return false;
7304             }
7305         } // isSrcOperand
7306
7307         bool
7308         isDstOperand(int opIdx) override
7309         {
7310             switch (opIdx) {
7311               case 0: //ssrc_0
7312                 return false;
7313               case 1: //ssrc_1
7314                 return false;
7315               default:
7316                 fatal("op idx %i out of bounds\n", opIdx);
7317                 return false;
7318             }
7319         } // isDstOperand
7320
7321         void execute(GPUDynInstPtr) override;
7322     }; // Inst_SOPC__S_CMP_GT_I32
7323
7324     class Inst_SOPC__S_CMP_GE_I32 : public Inst_SOPC
7325     {
7326       public:
7327         Inst_SOPC__S_CMP_GE_I32(InFmt_SOPC*);
7328         ~Inst_SOPC__S_CMP_GE_I32();
7329
7330         int
7331         getNumOperands() override
7332         {
7333             return numDstRegOperands() + numSrcRegOperands();
7334         } // getNumOperands
7335
7336         int numDstRegOperands() override { return 0; }
7337         int numSrcRegOperands() override { return 2; }
7338
7339         int
7340         getOperandSize(int opIdx) override
7341         {
7342             switch (opIdx) {
7343               case 0: //ssrc_0
7344                 return 4;
7345               case 1: //ssrc_1
7346                 return 4;
7347               default:
7348                 fatal("op idx %i out of bounds\n", opIdx);
7349                 return -1;
7350             }
7351         } // getOperandSize
7352
7353         bool
7354         isSrcOperand(int opIdx) override
7355         {
7356             switch (opIdx) {
7357               case 0: //ssrc_0
7358                 return true;
7359               case 1: //ssrc_1
7360                 return true;
7361               default:
7362                 fatal("op idx %i out of bounds\n", opIdx);
7363                 return false;
7364             }
7365         } // isSrcOperand
7366
7367         bool
7368         isDstOperand(int opIdx) override
7369         {
7370             switch (opIdx) {
7371               case 0: //ssrc_0
7372                 return false;
7373               case 1: //ssrc_1
7374                 return false;
7375               default:
7376                 fatal("op idx %i out of bounds\n", opIdx);
7377                 return false;
7378             }
7379         } // isDstOperand
7380
7381         void execute(GPUDynInstPtr) override;
7382     }; // Inst_SOPC__S_CMP_GE_I32
7383
7384     class Inst_SOPC__S_CMP_LT_I32 : public Inst_SOPC
7385     {
7386       public:
7387         Inst_SOPC__S_CMP_LT_I32(InFmt_SOPC*);
7388         ~Inst_SOPC__S_CMP_LT_I32();
7389
7390         int
7391         getNumOperands() override
7392         {
7393             return numDstRegOperands() + numSrcRegOperands();
7394         } // getNumOperands
7395
7396         int numDstRegOperands() override { return 0; }
7397         int numSrcRegOperands() override { return 2; }
7398
7399         int
7400         getOperandSize(int opIdx) override
7401         {
7402             switch (opIdx) {
7403               case 0: //ssrc_0
7404                 return 4;
7405               case 1: //ssrc_1
7406                 return 4;
7407               default:
7408                 fatal("op idx %i out of bounds\n", opIdx);
7409                 return -1;
7410             }
7411         } // getOperandSize
7412
7413         bool
7414         isSrcOperand(int opIdx) override
7415         {
7416             switch (opIdx) {
7417               case 0: //ssrc_0
7418                 return true;
7419               case 1: //ssrc_1
7420                 return true;
7421               default:
7422                 fatal("op idx %i out of bounds\n", opIdx);
7423                 return false;
7424             }
7425         } // isSrcOperand
7426
7427         bool
7428         isDstOperand(int opIdx) override
7429         {
7430             switch (opIdx) {
7431               case 0: //ssrc_0
7432                 return false;
7433               case 1: //ssrc_1
7434                 return false;
7435               default:
7436                 fatal("op idx %i out of bounds\n", opIdx);
7437                 return false;
7438             }
7439         } // isDstOperand
7440
7441         void execute(GPUDynInstPtr) override;
7442     }; // Inst_SOPC__S_CMP_LT_I32
7443
7444     class Inst_SOPC__S_CMP_LE_I32 : public Inst_SOPC
7445     {
7446       public:
7447         Inst_SOPC__S_CMP_LE_I32(InFmt_SOPC*);
7448         ~Inst_SOPC__S_CMP_LE_I32();
7449
7450         int
7451         getNumOperands() override
7452         {
7453             return numDstRegOperands() + numSrcRegOperands();
7454         } // getNumOperands
7455
7456         int numDstRegOperands() override { return 0; }
7457         int numSrcRegOperands() override { return 2; }
7458
7459         int
7460         getOperandSize(int opIdx) override
7461         {
7462             switch (opIdx) {
7463               case 0: //ssrc_0
7464                 return 4;
7465               case 1: //ssrc_1
7466                 return 4;
7467               default:
7468                 fatal("op idx %i out of bounds\n", opIdx);
7469                 return -1;
7470             }
7471         } // getOperandSize
7472
7473         bool
7474         isSrcOperand(int opIdx) override
7475         {
7476             switch (opIdx) {
7477               case 0: //ssrc_0
7478                 return true;
7479               case 1: //ssrc_1
7480                 return true;
7481               default:
7482                 fatal("op idx %i out of bounds\n", opIdx);
7483                 return false;
7484             }
7485         } // isSrcOperand
7486
7487         bool
7488         isDstOperand(int opIdx) override
7489         {
7490             switch (opIdx) {
7491               case 0: //ssrc_0
7492                 return false;
7493               case 1: //ssrc_1
7494                 return false;
7495               default:
7496                 fatal("op idx %i out of bounds\n", opIdx);
7497                 return false;
7498             }
7499         } // isDstOperand
7500
7501         void execute(GPUDynInstPtr) override;
7502     }; // Inst_SOPC__S_CMP_LE_I32
7503
7504     class Inst_SOPC__S_CMP_EQ_U32 : public Inst_SOPC
7505     {
7506       public:
7507         Inst_SOPC__S_CMP_EQ_U32(InFmt_SOPC*);
7508         ~Inst_SOPC__S_CMP_EQ_U32();
7509
7510         int
7511         getNumOperands() override
7512         {
7513             return numDstRegOperands() + numSrcRegOperands();
7514         } // getNumOperands
7515
7516         int numDstRegOperands() override { return 0; }
7517         int numSrcRegOperands() override { return 2; }
7518
7519         int
7520         getOperandSize(int opIdx) override
7521         {
7522             switch (opIdx) {
7523               case 0: //ssrc_0
7524                 return 4;
7525               case 1: //ssrc_1
7526                 return 4;
7527               default:
7528                 fatal("op idx %i out of bounds\n", opIdx);
7529                 return -1;
7530             }
7531         } // getOperandSize
7532
7533         bool
7534         isSrcOperand(int opIdx) override
7535         {
7536             switch (opIdx) {
7537               case 0: //ssrc_0
7538                 return true;
7539               case 1: //ssrc_1
7540                 return true;
7541               default:
7542                 fatal("op idx %i out of bounds\n", opIdx);
7543                 return false;
7544             }
7545         } // isSrcOperand
7546
7547         bool
7548         isDstOperand(int opIdx) override
7549         {
7550             switch (opIdx) {
7551               case 0: //ssrc_0
7552                 return false;
7553               case 1: //ssrc_1
7554                 return false;
7555               default:
7556                 fatal("op idx %i out of bounds\n", opIdx);
7557                 return false;
7558             }
7559         } // isDstOperand
7560
7561         void execute(GPUDynInstPtr) override;
7562     }; // Inst_SOPC__S_CMP_EQ_U32
7563
7564     class Inst_SOPC__S_CMP_LG_U32 : public Inst_SOPC
7565     {
7566       public:
7567         Inst_SOPC__S_CMP_LG_U32(InFmt_SOPC*);
7568         ~Inst_SOPC__S_CMP_LG_U32();
7569
7570         int
7571         getNumOperands() override
7572         {
7573             return numDstRegOperands() + numSrcRegOperands();
7574         } // getNumOperands
7575
7576         int numDstRegOperands() override { return 0; }
7577         int numSrcRegOperands() override { return 2; }
7578
7579         int
7580         getOperandSize(int opIdx) override
7581         {
7582             switch (opIdx) {
7583               case 0: //ssrc_0
7584                 return 4;
7585               case 1: //ssrc_1
7586                 return 4;
7587               default:
7588                 fatal("op idx %i out of bounds\n", opIdx);
7589                 return -1;
7590             }
7591         } // getOperandSize
7592
7593         bool
7594         isSrcOperand(int opIdx) override
7595         {
7596             switch (opIdx) {
7597               case 0: //ssrc_0
7598                 return true;
7599               case 1: //ssrc_1
7600                 return true;
7601               default:
7602                 fatal("op idx %i out of bounds\n", opIdx);
7603                 return false;
7604             }
7605         } // isSrcOperand
7606
7607         bool
7608         isDstOperand(int opIdx) override
7609         {
7610             switch (opIdx) {
7611               case 0: //ssrc_0
7612                 return false;
7613               case 1: //ssrc_1
7614                 return false;
7615               default:
7616                 fatal("op idx %i out of bounds\n", opIdx);
7617                 return false;
7618             }
7619         } // isDstOperand
7620
7621         void execute(GPUDynInstPtr) override;
7622     }; // Inst_SOPC__S_CMP_LG_U32
7623
7624     class Inst_SOPC__S_CMP_GT_U32 : public Inst_SOPC
7625     {
7626       public:
7627         Inst_SOPC__S_CMP_GT_U32(InFmt_SOPC*);
7628         ~Inst_SOPC__S_CMP_GT_U32();
7629
7630         int
7631         getNumOperands() override
7632         {
7633             return numDstRegOperands() + numSrcRegOperands();
7634         } // getNumOperands
7635
7636         int numDstRegOperands() override { return 0; }
7637         int numSrcRegOperands() override { return 2; }
7638
7639         int
7640         getOperandSize(int opIdx) override
7641         {
7642             switch (opIdx) {
7643               case 0: //ssrc_0
7644                 return 4;
7645               case 1: //ssrc_1
7646                 return 4;
7647               default:
7648                 fatal("op idx %i out of bounds\n", opIdx);
7649                 return -1;
7650             }
7651         } // getOperandSize
7652
7653         bool
7654         isSrcOperand(int opIdx) override
7655         {
7656             switch (opIdx) {
7657               case 0: //ssrc_0
7658                 return true;
7659               case 1: //ssrc_1
7660                 return true;
7661               default:
7662                 fatal("op idx %i out of bounds\n", opIdx);
7663                 return false;
7664             }
7665         } // isSrcOperand
7666
7667         bool
7668         isDstOperand(int opIdx) override
7669         {
7670             switch (opIdx) {
7671               case 0: //ssrc_0
7672                 return false;
7673               case 1: //ssrc_1
7674                 return false;
7675               default:
7676                 fatal("op idx %i out of bounds\n", opIdx);
7677                 return false;
7678             }
7679         } // isDstOperand
7680
7681         void execute(GPUDynInstPtr) override;
7682     }; // Inst_SOPC__S_CMP_GT_U32
7683
7684     class Inst_SOPC__S_CMP_GE_U32 : public Inst_SOPC
7685     {
7686       public:
7687         Inst_SOPC__S_CMP_GE_U32(InFmt_SOPC*);
7688         ~Inst_SOPC__S_CMP_GE_U32();
7689
7690         int
7691         getNumOperands() override
7692         {
7693             return numDstRegOperands() + numSrcRegOperands();
7694         } // getNumOperands
7695
7696         int numDstRegOperands() override { return 0; }
7697         int numSrcRegOperands() override { return 2; }
7698
7699         int
7700         getOperandSize(int opIdx) override
7701         {
7702             switch (opIdx) {
7703               case 0: //ssrc_0
7704                 return 4;
7705               case 1: //ssrc_1
7706                 return 4;
7707               default:
7708                 fatal("op idx %i out of bounds\n", opIdx);
7709                 return -1;
7710             }
7711         } // getOperandSize
7712
7713         bool
7714         isSrcOperand(int opIdx) override
7715         {
7716             switch (opIdx) {
7717               case 0: //ssrc_0
7718                 return true;
7719               case 1: //ssrc_1
7720                 return true;
7721               default:
7722                 fatal("op idx %i out of bounds\n", opIdx);
7723                 return false;
7724             }
7725         } // isSrcOperand
7726
7727         bool
7728         isDstOperand(int opIdx) override
7729         {
7730             switch (opIdx) {
7731               case 0: //ssrc_0
7732                 return false;
7733               case 1: //ssrc_1
7734                 return false;
7735               default:
7736                 fatal("op idx %i out of bounds\n", opIdx);
7737                 return false;
7738             }
7739         } // isDstOperand
7740
7741         void execute(GPUDynInstPtr) override;
7742     }; // Inst_SOPC__S_CMP_GE_U32
7743
7744     class Inst_SOPC__S_CMP_LT_U32 : public Inst_SOPC
7745     {
7746       public:
7747         Inst_SOPC__S_CMP_LT_U32(InFmt_SOPC*);
7748         ~Inst_SOPC__S_CMP_LT_U32();
7749
7750         int
7751         getNumOperands() override
7752         {
7753             return numDstRegOperands() + numSrcRegOperands();
7754         } // getNumOperands
7755
7756         int numDstRegOperands() override { return 0; }
7757         int numSrcRegOperands() override { return 2; }
7758
7759         int
7760         getOperandSize(int opIdx) override
7761         {
7762             switch (opIdx) {
7763               case 0: //ssrc_0
7764                 return 4;
7765               case 1: //ssrc_1
7766                 return 4;
7767               default:
7768                 fatal("op idx %i out of bounds\n", opIdx);
7769                 return -1;
7770             }
7771         } // getOperandSize
7772
7773         bool
7774         isSrcOperand(int opIdx) override
7775         {
7776             switch (opIdx) {
7777               case 0: //ssrc_0
7778                 return true;
7779               case 1: //ssrc_1
7780                 return true;
7781               default:
7782                 fatal("op idx %i out of bounds\n", opIdx);
7783                 return false;
7784             }
7785         } // isSrcOperand
7786
7787         bool
7788         isDstOperand(int opIdx) override
7789         {
7790             switch (opIdx) {
7791               case 0: //ssrc_0
7792                 return false;
7793               case 1: //ssrc_1
7794                 return false;
7795               default:
7796                 fatal("op idx %i out of bounds\n", opIdx);
7797                 return false;
7798             }
7799         } // isDstOperand
7800
7801         void execute(GPUDynInstPtr) override;
7802     }; // Inst_SOPC__S_CMP_LT_U32
7803
7804     class Inst_SOPC__S_CMP_LE_U32 : public Inst_SOPC
7805     {
7806       public:
7807         Inst_SOPC__S_CMP_LE_U32(InFmt_SOPC*);
7808         ~Inst_SOPC__S_CMP_LE_U32();
7809
7810         int
7811         getNumOperands() override
7812         {
7813             return numDstRegOperands() + numSrcRegOperands();
7814         } // getNumOperands
7815
7816         int numDstRegOperands() override { return 0; }
7817         int numSrcRegOperands() override { return 2; }
7818
7819         int
7820         getOperandSize(int opIdx) override
7821         {
7822             switch (opIdx) {
7823               case 0: //ssrc_0
7824                 return 4;
7825               case 1: //ssrc_1
7826                 return 4;
7827               default:
7828                 fatal("op idx %i out of bounds\n", opIdx);
7829                 return -1;
7830             }
7831         } // getOperandSize
7832
7833         bool
7834         isSrcOperand(int opIdx) override
7835         {
7836             switch (opIdx) {
7837               case 0: //ssrc_0
7838                 return true;
7839               case 1: //ssrc_1
7840                 return true;
7841               default:
7842                 fatal("op idx %i out of bounds\n", opIdx);
7843                 return false;
7844             }
7845         } // isSrcOperand
7846
7847         bool
7848         isDstOperand(int opIdx) override
7849         {
7850             switch (opIdx) {
7851               case 0: //ssrc_0
7852                 return false;
7853               case 1: //ssrc_1
7854                 return false;
7855               default:
7856                 fatal("op idx %i out of bounds\n", opIdx);
7857                 return false;
7858             }
7859         } // isDstOperand
7860
7861         void execute(GPUDynInstPtr) override;
7862     }; // Inst_SOPC__S_CMP_LE_U32
7863
7864     class Inst_SOPC__S_BITCMP0_B32 : public Inst_SOPC
7865     {
7866       public:
7867         Inst_SOPC__S_BITCMP0_B32(InFmt_SOPC*);
7868         ~Inst_SOPC__S_BITCMP0_B32();
7869
7870         int
7871         getNumOperands() override
7872         {
7873             return numDstRegOperands() + numSrcRegOperands();
7874         } // getNumOperands
7875
7876         int numDstRegOperands() override { return 0; }
7877         int numSrcRegOperands() override { return 2; }
7878
7879         int
7880         getOperandSize(int opIdx) override
7881         {
7882             switch (opIdx) {
7883               case 0: //ssrc_0
7884                 return 4;
7885               case 1: //ssrc_1
7886                 return 4;
7887               default:
7888                 fatal("op idx %i out of bounds\n", opIdx);
7889                 return -1;
7890             }
7891         } // getOperandSize
7892
7893         bool
7894         isSrcOperand(int opIdx) override
7895         {
7896             switch (opIdx) {
7897               case 0: //ssrc_0
7898                 return true;
7899               case 1: //ssrc_1
7900                 return true;
7901               default:
7902                 fatal("op idx %i out of bounds\n", opIdx);
7903                 return false;
7904             }
7905         } // isSrcOperand
7906
7907         bool
7908         isDstOperand(int opIdx) override
7909         {
7910             switch (opIdx) {
7911               case 0: //ssrc_0
7912                 return false;
7913               case 1: //ssrc_1
7914                 return false;
7915               default:
7916                 fatal("op idx %i out of bounds\n", opIdx);
7917                 return false;
7918             }
7919         } // isDstOperand
7920
7921         void execute(GPUDynInstPtr) override;
7922     }; // Inst_SOPC__S_BITCMP0_B32
7923
7924     class Inst_SOPC__S_BITCMP1_B32 : public Inst_SOPC
7925     {
7926       public:
7927         Inst_SOPC__S_BITCMP1_B32(InFmt_SOPC*);
7928         ~Inst_SOPC__S_BITCMP1_B32();
7929
7930         int
7931         getNumOperands() override
7932         {
7933             return numDstRegOperands() + numSrcRegOperands();
7934         } // getNumOperands
7935
7936         int numDstRegOperands() override { return 0; }
7937         int numSrcRegOperands() override { return 2; }
7938
7939         int
7940         getOperandSize(int opIdx) override
7941         {
7942             switch (opIdx) {
7943               case 0: //ssrc_0
7944                 return 4;
7945               case 1: //ssrc_1
7946                 return 4;
7947               default:
7948                 fatal("op idx %i out of bounds\n", opIdx);
7949                 return -1;
7950             }
7951         } // getOperandSize
7952
7953         bool
7954         isSrcOperand(int opIdx) override
7955         {
7956             switch (opIdx) {
7957               case 0: //ssrc_0
7958                 return true;
7959               case 1: //ssrc_1
7960                 return true;
7961               default:
7962                 fatal("op idx %i out of bounds\n", opIdx);
7963                 return false;
7964             }
7965         } // isSrcOperand
7966
7967         bool
7968         isDstOperand(int opIdx) override
7969         {
7970             switch (opIdx) {
7971               case 0: //ssrc_0
7972                 return false;
7973               case 1: //ssrc_1
7974                 return false;
7975               default:
7976                 fatal("op idx %i out of bounds\n", opIdx);
7977                 return false;
7978             }
7979         } // isDstOperand
7980
7981         void execute(GPUDynInstPtr) override;
7982     }; // Inst_SOPC__S_BITCMP1_B32
7983
7984     class Inst_SOPC__S_BITCMP0_B64 : public Inst_SOPC
7985     {
7986       public:
7987         Inst_SOPC__S_BITCMP0_B64(InFmt_SOPC*);
7988         ~Inst_SOPC__S_BITCMP0_B64();
7989
7990         int
7991         getNumOperands() override
7992         {
7993             return numDstRegOperands() + numSrcRegOperands();
7994         } // getNumOperands
7995
7996         int numDstRegOperands() override { return 0; }
7997         int numSrcRegOperands() override { return 2; }
7998
7999         int
8000         getOperandSize(int opIdx) override
8001         {
8002             switch (opIdx) {
8003               case 0: //ssrc_0
8004                 return 8;
8005               case 1: //ssrc_1
8006                 return 4;
8007               default:
8008                 fatal("op idx %i out of bounds\n", opIdx);
8009                 return -1;
8010             }
8011         } // getOperandSize
8012
8013         bool
8014         isSrcOperand(int opIdx) override
8015         {
8016             switch (opIdx) {
8017               case 0: //ssrc_0
8018                 return true;
8019               case 1: //ssrc_1
8020                 return true;
8021               default:
8022                 fatal("op idx %i out of bounds\n", opIdx);
8023                 return false;
8024             }
8025         } // isSrcOperand
8026
8027         bool
8028         isDstOperand(int opIdx) override
8029         {
8030             switch (opIdx) {
8031               case 0: //ssrc_0
8032                 return false;
8033               case 1: //ssrc_1
8034                 return false;
8035               default:
8036                 fatal("op idx %i out of bounds\n", opIdx);
8037                 return false;
8038             }
8039         } // isDstOperand
8040
8041         void execute(GPUDynInstPtr) override;
8042     }; // Inst_SOPC__S_BITCMP0_B64
8043
8044     class Inst_SOPC__S_BITCMP1_B64 : public Inst_SOPC
8045     {
8046       public:
8047         Inst_SOPC__S_BITCMP1_B64(InFmt_SOPC*);
8048         ~Inst_SOPC__S_BITCMP1_B64();
8049
8050         int
8051         getNumOperands() override
8052         {
8053             return numDstRegOperands() + numSrcRegOperands();
8054         } // getNumOperands
8055
8056         int numDstRegOperands() override { return 0; }
8057         int numSrcRegOperands() override { return 2; }
8058
8059         int
8060         getOperandSize(int opIdx) override
8061         {
8062             switch (opIdx) {
8063               case 0: //ssrc_0
8064                 return 8;
8065               case 1: //ssrc_1
8066                 return 4;
8067               default:
8068                 fatal("op idx %i out of bounds\n", opIdx);
8069                 return -1;
8070             }
8071         } // getOperandSize
8072
8073         bool
8074         isSrcOperand(int opIdx) override
8075         {
8076             switch (opIdx) {
8077               case 0: //ssrc_0
8078                 return true;
8079               case 1: //ssrc_1
8080                 return true;
8081               default:
8082                 fatal("op idx %i out of bounds\n", opIdx);
8083                 return false;
8084             }
8085         } // isSrcOperand
8086
8087         bool
8088         isDstOperand(int opIdx) override
8089         {
8090             switch (opIdx) {
8091               case 0: //ssrc_0
8092                 return false;
8093               case 1: //ssrc_1
8094                 return false;
8095               default:
8096                 fatal("op idx %i out of bounds\n", opIdx);
8097                 return false;
8098             }
8099         } // isDstOperand
8100
8101         void execute(GPUDynInstPtr) override;
8102     }; // Inst_SOPC__S_BITCMP1_B64
8103
8104     class Inst_SOPC__S_SETVSKIP : public Inst_SOPC
8105     {
8106       public:
8107         Inst_SOPC__S_SETVSKIP(InFmt_SOPC*);
8108         ~Inst_SOPC__S_SETVSKIP();
8109
8110         int
8111         getNumOperands() override
8112         {
8113             return numDstRegOperands() + numSrcRegOperands();
8114         } // getNumOperands
8115
8116         int numDstRegOperands() override { return 0; }
8117         int numSrcRegOperands() override { return 2; }
8118
8119         int
8120         getOperandSize(int opIdx) override
8121         {
8122             switch (opIdx) {
8123               case 0: //ssrc_0
8124                 return 4;
8125               case 1: //ssrc_1
8126                 return 4;
8127               default:
8128                 fatal("op idx %i out of bounds\n", opIdx);
8129                 return -1;
8130             }
8131         } // getOperandSize
8132
8133         bool
8134         isSrcOperand(int opIdx) override
8135         {
8136             switch (opIdx) {
8137               case 0: //ssrc_0
8138                 return true;
8139               case 1: //ssrc_1
8140                 return true;
8141               default:
8142                 fatal("op idx %i out of bounds\n", opIdx);
8143                 return false;
8144             }
8145         } // isSrcOperand
8146
8147         bool
8148         isDstOperand(int opIdx) override
8149         {
8150             switch (opIdx) {
8151               case 0: //ssrc_0
8152                 return false;
8153               case 1: //ssrc_1
8154                 return false;
8155               default:
8156                 fatal("op idx %i out of bounds\n", opIdx);
8157                 return false;
8158             }
8159         } // isDstOperand
8160
8161         void execute(GPUDynInstPtr) override;
8162     }; // Inst_SOPC__S_SETVSKIP
8163
8164     class Inst_SOPC__S_SET_GPR_IDX_ON : public Inst_SOPC
8165     {
8166       public:
8167         Inst_SOPC__S_SET_GPR_IDX_ON(InFmt_SOPC*);
8168         ~Inst_SOPC__S_SET_GPR_IDX_ON();
8169
8170         int
8171         getNumOperands() override
8172         {
8173             return numDstRegOperands() + numSrcRegOperands();
8174         } // getNumOperands
8175
8176         int numDstRegOperands() override { return 0; }
8177         int numSrcRegOperands() override { return 2; }
8178
8179         int
8180         getOperandSize(int opIdx) override
8181         {
8182             switch (opIdx) {
8183               case 0: //ssrc_0
8184                 return 4;
8185               case 1: //simm4
8186                 return 4;
8187               default:
8188                 fatal("op idx %i out of bounds\n", opIdx);
8189                 return -1;
8190             }
8191         } // getOperandSize
8192
8193         bool
8194         isSrcOperand(int opIdx) override
8195         {
8196             switch (opIdx) {
8197               case 0: //ssrc_0
8198                 return true;
8199               case 1: //simm4
8200                 return true;
8201               default:
8202                 fatal("op idx %i out of bounds\n", opIdx);
8203                 return false;
8204             }
8205         } // isSrcOperand
8206
8207         bool
8208         isDstOperand(int opIdx) override
8209         {
8210             switch (opIdx) {
8211               case 0: //ssrc_0
8212                 return false;
8213               case 1: //simm4
8214                 return false;
8215               default:
8216                 fatal("op idx %i out of bounds\n", opIdx);
8217                 return false;
8218             }
8219         } // isDstOperand
8220
8221         void execute(GPUDynInstPtr) override;
8222     }; // Inst_SOPC__S_SET_GPR_IDX_ON
8223
8224     class Inst_SOPC__S_CMP_EQ_U64 : public Inst_SOPC
8225     {
8226       public:
8227         Inst_SOPC__S_CMP_EQ_U64(InFmt_SOPC*);
8228         ~Inst_SOPC__S_CMP_EQ_U64();
8229
8230         int
8231         getNumOperands() override
8232         {
8233             return numDstRegOperands() + numSrcRegOperands();
8234         } // getNumOperands
8235
8236         int numDstRegOperands() override { return 0; }
8237         int numSrcRegOperands() override { return 2; }
8238
8239         int
8240         getOperandSize(int opIdx) override
8241         {
8242             switch (opIdx) {
8243               case 0: //ssrc_0
8244                 return 8;
8245               case 1: //ssrc_1
8246                 return 8;
8247               default:
8248                 fatal("op idx %i out of bounds\n", opIdx);
8249                 return -1;
8250             }
8251         } // getOperandSize
8252
8253         bool
8254         isSrcOperand(int opIdx) override
8255         {
8256             switch (opIdx) {
8257               case 0: //ssrc_0
8258                 return true;
8259               case 1: //ssrc_1
8260                 return true;
8261               default:
8262                 fatal("op idx %i out of bounds\n", opIdx);
8263                 return false;
8264             }
8265         } // isSrcOperand
8266
8267         bool
8268         isDstOperand(int opIdx) override
8269         {
8270             switch (opIdx) {
8271               case 0: //ssrc_0
8272                 return false;
8273               case 1: //ssrc_1
8274                 return false;
8275               default:
8276                 fatal("op idx %i out of bounds\n", opIdx);
8277                 return false;
8278             }
8279         } // isDstOperand
8280
8281         void execute(GPUDynInstPtr) override;
8282     }; // Inst_SOPC__S_CMP_EQ_U64
8283
8284     class Inst_SOPC__S_CMP_LG_U64 : public Inst_SOPC
8285     {
8286       public:
8287         Inst_SOPC__S_CMP_LG_U64(InFmt_SOPC*);
8288         ~Inst_SOPC__S_CMP_LG_U64();
8289
8290         int
8291         getNumOperands() override
8292         {
8293             return numDstRegOperands() + numSrcRegOperands();
8294         } // getNumOperands
8295
8296         int numDstRegOperands() override { return 0; }
8297         int numSrcRegOperands() override { return 2; }
8298
8299         int
8300         getOperandSize(int opIdx) override
8301         {
8302             switch (opIdx) {
8303               case 0: //ssrc_0
8304                 return 8;
8305               case 1: //ssrc_1
8306                 return 8;
8307               default:
8308                 fatal("op idx %i out of bounds\n", opIdx);
8309                 return -1;
8310             }
8311         } // getOperandSize
8312
8313         bool
8314         isSrcOperand(int opIdx) override
8315         {
8316             switch (opIdx) {
8317               case 0: //ssrc_0
8318                 return true;
8319               case 1: //ssrc_1
8320                 return true;
8321               default:
8322                 fatal("op idx %i out of bounds\n", opIdx);
8323                 return false;
8324             }
8325         } // isSrcOperand
8326
8327         bool
8328         isDstOperand(int opIdx) override
8329         {
8330             switch (opIdx) {
8331               case 0: //ssrc_0
8332                 return false;
8333               case 1: //ssrc_1
8334                 return false;
8335               default:
8336                 fatal("op idx %i out of bounds\n", opIdx);
8337                 return false;
8338             }
8339         } // isDstOperand
8340
8341         void execute(GPUDynInstPtr) override;
8342     }; // Inst_SOPC__S_CMP_LG_U64
8343
8344     class Inst_SOPP__S_NOP : public Inst_SOPP
8345     {
8346       public:
8347         Inst_SOPP__S_NOP(InFmt_SOPP*);
8348         ~Inst_SOPP__S_NOP();
8349
8350         int
8351         getNumOperands() override
8352         {
8353             return numDstRegOperands() + numSrcRegOperands();
8354         } // getNumOperands
8355
8356         int numDstRegOperands() override { return 0; }
8357         int numSrcRegOperands() override { return 1; }
8358
8359         int
8360         getOperandSize(int opIdx) override
8361         {
8362             switch (opIdx) {
8363               case 0: //simm16
8364                 return 2;
8365               default:
8366                 fatal("op idx %i out of bounds\n", opIdx);
8367                 return -1;
8368             }
8369         } // getOperandSize
8370
8371         bool
8372         isSrcOperand(int opIdx) override
8373         {
8374             switch (opIdx) {
8375               case 0: //simm16
8376                 return true;
8377               default:
8378                 fatal("op idx %i out of bounds\n", opIdx);
8379                 return false;
8380             }
8381         } // isSrcOperand
8382
8383         bool
8384         isDstOperand(int opIdx) override
8385         {
8386             switch (opIdx) {
8387               case 0: //simm16
8388                 return false;
8389               default:
8390                 fatal("op idx %i out of bounds\n", opIdx);
8391                 return false;
8392             }
8393         } // isDstOperand
8394
8395         void execute(GPUDynInstPtr) override;
8396     }; // Inst_SOPP__S_NOP
8397
8398     class Inst_SOPP__S_ENDPGM : public Inst_SOPP
8399     {
8400       public:
8401         Inst_SOPP__S_ENDPGM(InFmt_SOPP*);
8402         ~Inst_SOPP__S_ENDPGM();
8403
8404         int
8405         getNumOperands() override
8406         {
8407             return numDstRegOperands() + numSrcRegOperands();
8408         } // getNumOperands
8409
8410         int numDstRegOperands() override { return 0; }
8411         int numSrcRegOperands() override { return 0; }
8412
8413         int
8414         getOperandSize(int opIdx) override
8415         {
8416             switch (opIdx) {
8417               case 0: //simm16
8418                 return 2;
8419               default:
8420                 fatal("op idx %i out of bounds\n", opIdx);
8421                 return -1;
8422             }
8423         } // getOperandSize
8424
8425         bool
8426         isSrcOperand(int opIdx) override
8427         {
8428             switch (opIdx) {
8429               case 0: //simm16
8430                 return true;
8431               default:
8432                 fatal("op idx %i out of bounds\n", opIdx);
8433                 return false;
8434             }
8435         } // isSrcOperand
8436
8437         bool
8438         isDstOperand(int opIdx) override
8439         {
8440             switch (opIdx) {
8441               case 0: //simm16
8442                 return false;
8443               default:
8444                 fatal("op idx %i out of bounds\n", opIdx);
8445                 return false;
8446             }
8447         } // isDstOperand
8448
8449         void execute(GPUDynInstPtr) override;
8450     }; // Inst_SOPP__S_ENDPGM
8451
8452     class Inst_SOPP__S_BRANCH : public Inst_SOPP
8453     {
8454       public:
8455         Inst_SOPP__S_BRANCH(InFmt_SOPP*);
8456         ~Inst_SOPP__S_BRANCH();
8457
8458         int
8459         getNumOperands() override
8460         {
8461             return numDstRegOperands() + numSrcRegOperands();
8462         } // getNumOperands
8463
8464         int numDstRegOperands() override { return 0; }
8465         int numSrcRegOperands() override { return 1; }
8466
8467         int
8468         getOperandSize(int opIdx) override
8469         {
8470             switch (opIdx) {
8471               case 0: //label
8472                 return 2;
8473               default:
8474                 fatal("op idx %i out of bounds\n", opIdx);
8475                 return -1;
8476             }
8477         } // getOperandSize
8478
8479         bool
8480         isSrcOperand(int opIdx) override
8481         {
8482             switch (opIdx) {
8483               case 0: //label
8484                 return true;
8485               default:
8486                 fatal("op idx %i out of bounds\n", opIdx);
8487                 return false;
8488             }
8489         } // isSrcOperand
8490
8491         bool
8492         isDstOperand(int opIdx) override
8493         {
8494             switch (opIdx) {
8495               case 0: //label
8496                 return false;
8497               default:
8498                 fatal("op idx %i out of bounds\n", opIdx);
8499                 return false;
8500             }
8501         } // isDstOperand
8502
8503         void execute(GPUDynInstPtr) override;
8504     }; // Inst_SOPP__S_BRANCH
8505
8506     class Inst_SOPP__S_WAKEUP : public Inst_SOPP
8507     {
8508       public:
8509         Inst_SOPP__S_WAKEUP(InFmt_SOPP*);
8510         ~Inst_SOPP__S_WAKEUP();
8511
8512         int
8513         getNumOperands() override
8514         {
8515             return numDstRegOperands() + numSrcRegOperands();
8516         } // getNumOperands
8517
8518         int numDstRegOperands() override { return 0; }
8519         int numSrcRegOperands() override { return 0; }
8520
8521         int
8522         getOperandSize(int opIdx) override
8523         {
8524             switch (opIdx) {
8525               case 0: //simm16
8526                 return 2;
8527               default:
8528                 fatal("op idx %i out of bounds\n", opIdx);
8529                 return -1;
8530             }
8531         } // getOperandSize
8532
8533         bool
8534         isSrcOperand(int opIdx) override
8535         {
8536             switch (opIdx) {
8537               case 0: //simm16
8538                 return true;
8539               default:
8540                 fatal("op idx %i out of bounds\n", opIdx);
8541                 return false;
8542             }
8543         } // isSrcOperand
8544
8545         bool
8546         isDstOperand(int opIdx) override
8547         {
8548             switch (opIdx) {
8549               case 0: //simm16
8550                 return false;
8551               default:
8552                 fatal("op idx %i out of bounds\n", opIdx);
8553                 return false;
8554             }
8555         } // isDstOperand
8556
8557         void execute(GPUDynInstPtr) override;
8558     }; // Inst_SOPP__S_WAKEUP
8559
8560     class Inst_SOPP__S_CBRANCH_SCC0 : public Inst_SOPP
8561     {
8562       public:
8563         Inst_SOPP__S_CBRANCH_SCC0(InFmt_SOPP*);
8564         ~Inst_SOPP__S_CBRANCH_SCC0();
8565
8566         int
8567         getNumOperands() override
8568         {
8569             return numDstRegOperands() + numSrcRegOperands();
8570         } // getNumOperands
8571
8572         int numDstRegOperands() override { return 0; }
8573         int numSrcRegOperands() override { return 1; }
8574
8575         int
8576         getOperandSize(int opIdx) override
8577         {
8578             switch (opIdx) {
8579               case 0: //label
8580                 return 2;
8581               default:
8582                 fatal("op idx %i out of bounds\n", opIdx);
8583                 return -1;
8584             }
8585         } // getOperandSize
8586
8587         bool
8588         isSrcOperand(int opIdx) override
8589         {
8590             switch (opIdx) {
8591               case 0: //label
8592                 return true;
8593               default:
8594                 fatal("op idx %i out of bounds\n", opIdx);
8595                 return false;
8596             }
8597         } // isSrcOperand
8598
8599         bool
8600         isDstOperand(int opIdx) override
8601         {
8602             switch (opIdx) {
8603               case 0: //label
8604                 return false;
8605               default:
8606                 fatal("op idx %i out of bounds\n", opIdx);
8607                 return false;
8608             }
8609         } // isDstOperand
8610
8611         void execute(GPUDynInstPtr) override;
8612     }; // Inst_SOPP__S_CBRANCH_SCC0
8613
8614     class Inst_SOPP__S_CBRANCH_SCC1 : public Inst_SOPP
8615     {
8616       public:
8617         Inst_SOPP__S_CBRANCH_SCC1(InFmt_SOPP*);
8618         ~Inst_SOPP__S_CBRANCH_SCC1();
8619
8620         int
8621         getNumOperands() override
8622         {
8623             return numDstRegOperands() + numSrcRegOperands();
8624         } // getNumOperands
8625
8626         int numDstRegOperands() override { return 0; }
8627         int numSrcRegOperands() override { return 1; }
8628
8629         int
8630         getOperandSize(int opIdx) override
8631         {
8632             switch (opIdx) {
8633               case 0: //label
8634                 return 2;
8635               default:
8636                 fatal("op idx %i out of bounds\n", opIdx);
8637                 return -1;
8638             }
8639         } // getOperandSize
8640
8641         bool
8642         isSrcOperand(int opIdx) override
8643         {
8644             switch (opIdx) {
8645               case 0: //label
8646                 return true;
8647               default:
8648                 fatal("op idx %i out of bounds\n", opIdx);
8649                 return false;
8650             }
8651         } // isSrcOperand
8652
8653         bool
8654         isDstOperand(int opIdx) override
8655         {
8656             switch (opIdx) {
8657               case 0: //label
8658                 return false;
8659               default:
8660                 fatal("op idx %i out of bounds\n", opIdx);
8661                 return false;
8662             }
8663         } // isDstOperand
8664
8665         void execute(GPUDynInstPtr) override;
8666     }; // Inst_SOPP__S_CBRANCH_SCC1
8667
8668     class Inst_SOPP__S_CBRANCH_VCCZ : public Inst_SOPP
8669     {
8670       public:
8671         Inst_SOPP__S_CBRANCH_VCCZ(InFmt_SOPP*);
8672         ~Inst_SOPP__S_CBRANCH_VCCZ();
8673
8674         int
8675         getNumOperands() override
8676         {
8677             return numDstRegOperands() + numSrcRegOperands();
8678         } // getNumOperands
8679
8680         int numDstRegOperands() override { return 0; }
8681         int numSrcRegOperands() override { return 2; }
8682
8683         int
8684         getOperandSize(int opIdx) override
8685         {
8686             switch (opIdx) {
8687               case 0: //label
8688                 return 2;
8689               case 1:
8690                 return 8;
8691               default:
8692                 fatal("op idx %i out of bounds\n", opIdx);
8693                 return -1;
8694             }
8695         } // getOperandSize
8696
8697         bool
8698         isSrcOperand(int opIdx) override
8699         {
8700             switch (opIdx) {
8701               case 0: //label
8702                 return true;
8703               case 1:
8704                 return true;
8705               default:
8706                 fatal("op idx %i out of bounds\n", opIdx);
8707                 return false;
8708             }
8709         } // isSrcOperand
8710
8711         bool
8712         isDstOperand(int opIdx) override
8713         {
8714             switch (opIdx) {
8715               case 0: //label
8716                 return false;
8717               case 1:
8718                 return false;
8719               default:
8720                 fatal("op idx %i out of bounds\n", opIdx);
8721                 return false;
8722             }
8723         } // isDstOperand
8724
8725         void execute(GPUDynInstPtr) override;
8726     }; // Inst_SOPP__S_CBRANCH_VCCZ
8727
8728     class Inst_SOPP__S_CBRANCH_VCCNZ : public Inst_SOPP
8729     {
8730       public:
8731         Inst_SOPP__S_CBRANCH_VCCNZ(InFmt_SOPP*);
8732         ~Inst_SOPP__S_CBRANCH_VCCNZ();
8733
8734         int
8735         getNumOperands() override
8736         {
8737             return numDstRegOperands() + numSrcRegOperands();
8738         } // getNumOperands
8739
8740         int numDstRegOperands() override { return 0; }
8741         int numSrcRegOperands() override { return 2; }
8742
8743         int
8744         getOperandSize(int opIdx) override
8745         {
8746             switch (opIdx) {
8747               case 0: //label
8748                 return 2;
8749               case 1:
8750                 return 8;
8751               default:
8752                 fatal("op idx %i out of bounds\n", opIdx);
8753                 return -1;
8754             }
8755         } // getOperandSize
8756
8757         bool
8758         isSrcOperand(int opIdx) override
8759         {
8760             switch (opIdx) {
8761               case 0: //label
8762                 return true;
8763               case 1:
8764                 return true;
8765               default:
8766                 fatal("op idx %i out of bounds\n", opIdx);
8767                 return false;
8768             }
8769         } // isSrcOperand
8770
8771         bool
8772         isDstOperand(int opIdx) override
8773         {
8774             switch (opIdx) {
8775               case 0: //label
8776                 return false;
8777               case 1:
8778                 return false;
8779               default:
8780                 fatal("op idx %i out of bounds\n", opIdx);
8781                 return false;
8782             }
8783         } // isDstOperand
8784
8785         void execute(GPUDynInstPtr) override;
8786     }; // Inst_SOPP__S_CBRANCH_VCCNZ
8787
8788     class Inst_SOPP__S_CBRANCH_EXECZ : public Inst_SOPP
8789     {
8790       public:
8791         Inst_SOPP__S_CBRANCH_EXECZ(InFmt_SOPP*);
8792         ~Inst_SOPP__S_CBRANCH_EXECZ();
8793
8794         int
8795         getNumOperands() override
8796         {
8797             return numDstRegOperands() + numSrcRegOperands();
8798         } // getNumOperands
8799
8800         int numDstRegOperands() override { return 0; }
8801         int numSrcRegOperands() override { return 1; }
8802
8803         int
8804         getOperandSize(int opIdx) override
8805         {
8806             switch (opIdx) {
8807               case 0: //label
8808                 return 2;
8809               default:
8810                 fatal("op idx %i out of bounds\n", opIdx);
8811                 return -1;
8812             }
8813         } // getOperandSize
8814
8815         bool
8816         isSrcOperand(int opIdx) override
8817         {
8818             switch (opIdx) {
8819               case 0: //label
8820                 return true;
8821               default:
8822                 fatal("op idx %i out of bounds\n", opIdx);
8823                 return false;
8824             }
8825         } // isSrcOperand
8826
8827         bool
8828         isDstOperand(int opIdx) override
8829         {
8830             switch (opIdx) {
8831               case 0: //label
8832                 return false;
8833               default:
8834                 fatal("op idx %i out of bounds\n", opIdx);
8835                 return false;
8836             }
8837         } // isDstOperand
8838
8839         void execute(GPUDynInstPtr) override;
8840     }; // Inst_SOPP__S_CBRANCH_EXECZ
8841
8842     class Inst_SOPP__S_CBRANCH_EXECNZ : public Inst_SOPP
8843     {
8844       public:
8845         Inst_SOPP__S_CBRANCH_EXECNZ(InFmt_SOPP*);
8846         ~Inst_SOPP__S_CBRANCH_EXECNZ();
8847
8848         int
8849         getNumOperands() override
8850         {
8851             return numDstRegOperands() + numSrcRegOperands();
8852         } // getNumOperands
8853
8854         int numDstRegOperands() override { return 0; }
8855         int numSrcRegOperands() override { return 1; }
8856
8857         int
8858         getOperandSize(int opIdx) override
8859         {
8860             switch (opIdx) {
8861               case 0: //label
8862                 return 2;
8863               default:
8864                 fatal("op idx %i out of bounds\n", opIdx);
8865                 return -1;
8866             }
8867         } // getOperandSize
8868
8869         bool
8870         isSrcOperand(int opIdx) override
8871         {
8872             switch (opIdx) {
8873               case 0: //label
8874                 return true;
8875               default:
8876                 fatal("op idx %i out of bounds\n", opIdx);
8877                 return false;
8878             }
8879         } // isSrcOperand
8880
8881         bool
8882         isDstOperand(int opIdx) override
8883         {
8884             switch (opIdx) {
8885               case 0: //label
8886                 return false;
8887               default:
8888                 fatal("op idx %i out of bounds\n", opIdx);
8889                 return false;
8890             }
8891         } // isDstOperand
8892
8893         void execute(GPUDynInstPtr) override;
8894     }; // Inst_SOPP__S_CBRANCH_EXECNZ
8895
8896     class Inst_SOPP__S_BARRIER : public Inst_SOPP
8897     {
8898       public:
8899         Inst_SOPP__S_BARRIER(InFmt_SOPP*);
8900         ~Inst_SOPP__S_BARRIER();
8901
8902         int
8903         getNumOperands() override
8904         {
8905             return numDstRegOperands() + numSrcRegOperands();
8906         } // getNumOperands
8907
8908         int numDstRegOperands() override { return 0; }
8909         int numSrcRegOperands() override { return 0; }
8910
8911         int
8912         getOperandSize(int opIdx) override
8913         {
8914             switch (opIdx) {
8915               case 0: //simm16
8916                 return 2;
8917               default:
8918                 fatal("op idx %i out of bounds\n", opIdx);
8919                 return -1;
8920             }
8921         } // getOperandSize
8922
8923         bool
8924         isSrcOperand(int opIdx) override
8925         {
8926             switch (opIdx) {
8927               case 0: //simm16
8928                 return true;
8929               default:
8930                 fatal("op idx %i out of bounds\n", opIdx);
8931                 return false;
8932             }
8933         } // isSrcOperand
8934
8935         bool
8936         isDstOperand(int opIdx) override
8937         {
8938             switch (opIdx) {
8939               case 0: //simm16
8940                 return false;
8941               default:
8942                 fatal("op idx %i out of bounds\n", opIdx);
8943                 return false;
8944             }
8945         } // isDstOperand
8946
8947         void execute(GPUDynInstPtr) override;
8948     }; // Inst_SOPP__S_BARRIER
8949
8950     class Inst_SOPP__S_SETKILL : public Inst_SOPP
8951     {
8952       public:
8953         Inst_SOPP__S_SETKILL(InFmt_SOPP*);
8954         ~Inst_SOPP__S_SETKILL();
8955
8956         int
8957         getNumOperands() override
8958         {
8959             return numDstRegOperands() + numSrcRegOperands();
8960         } // getNumOperands
8961
8962         int numDstRegOperands() override { return 0; }
8963         int numSrcRegOperands() override { return 1; }
8964
8965         int
8966         getOperandSize(int opIdx) override
8967         {
8968             switch (opIdx) {
8969               case 0: //simm16
8970                 return 2;
8971               default:
8972                 fatal("op idx %i out of bounds\n", opIdx);
8973                 return -1;
8974             }
8975         } // getOperandSize
8976
8977         bool
8978         isSrcOperand(int opIdx) override
8979         {
8980             switch (opIdx) {
8981               case 0: //simm16
8982                 return true;
8983               default:
8984                 fatal("op idx %i out of bounds\n", opIdx);
8985                 return false;
8986             }
8987         } // isSrcOperand
8988
8989         bool
8990         isDstOperand(int opIdx) override
8991         {
8992             switch (opIdx) {
8993               case 0: //simm16
8994                 return false;
8995               default:
8996                 fatal("op idx %i out of bounds\n", opIdx);
8997                 return false;
8998             }
8999         } // isDstOperand
9000
9001         void execute(GPUDynInstPtr) override;
9002     }; // Inst_SOPP__S_SETKILL
9003
9004     class Inst_SOPP__S_WAITCNT : public Inst_SOPP
9005     {
9006       public:
9007         Inst_SOPP__S_WAITCNT(InFmt_SOPP*);
9008         ~Inst_SOPP__S_WAITCNT();
9009
9010         int
9011         getNumOperands() override
9012         {
9013             return numDstRegOperands() + numSrcRegOperands();
9014         } // getNumOperands
9015
9016         int numDstRegOperands() override { return 0; }
9017         int numSrcRegOperands() override { return 1; }
9018
9019         int
9020         getOperandSize(int opIdx) override
9021         {
9022             switch (opIdx) {
9023               case 0: //simm16
9024                 return 2;
9025               default:
9026                 fatal("op idx %i out of bounds\n", opIdx);
9027                 return -1;
9028             }
9029         } // getOperandSize
9030
9031         bool
9032         isSrcOperand(int opIdx) override
9033         {
9034             switch (opIdx) {
9035               case 0: //simm16
9036                 return true;
9037               default:
9038                 fatal("op idx %i out of bounds\n", opIdx);
9039                 return false;
9040             }
9041         } // isSrcOperand
9042
9043         bool
9044         isDstOperand(int opIdx) override
9045         {
9046             switch (opIdx) {
9047               case 0: //simm16
9048                 return false;
9049               default:
9050                 fatal("op idx %i out of bounds\n", opIdx);
9051                 return false;
9052             }
9053         } // isDstOperand
9054
9055         void execute(GPUDynInstPtr) override;
9056     }; // Inst_SOPP__S_WAITCNT
9057
9058     class Inst_SOPP__S_SETHALT : public Inst_SOPP
9059     {
9060       public:
9061         Inst_SOPP__S_SETHALT(InFmt_SOPP*);
9062         ~Inst_SOPP__S_SETHALT();
9063
9064         int
9065         getNumOperands() override
9066         {
9067             return numDstRegOperands() + numSrcRegOperands();
9068         } // getNumOperands
9069
9070         int numDstRegOperands() override { return 0; }
9071         int numSrcRegOperands() override { return 1; }
9072
9073         int
9074         getOperandSize(int opIdx) override
9075         {
9076             switch (opIdx) {
9077               case 0: //simm16
9078                 return 2;
9079               default:
9080                 fatal("op idx %i out of bounds\n", opIdx);
9081                 return -1;
9082             }
9083         } // getOperandSize
9084
9085         bool
9086         isSrcOperand(int opIdx) override
9087         {
9088             switch (opIdx) {
9089               case 0: //simm16
9090                 return true;
9091               default:
9092                 fatal("op idx %i out of bounds\n", opIdx);
9093                 return false;
9094             }
9095         } // isSrcOperand
9096
9097         bool
9098         isDstOperand(int opIdx) override
9099         {
9100             switch (opIdx) {
9101               case 0: //simm16
9102                 return false;
9103               default:
9104                 fatal("op idx %i out of bounds\n", opIdx);
9105                 return false;
9106             }
9107         } // isDstOperand
9108
9109         void execute(GPUDynInstPtr) override;
9110     }; // Inst_SOPP__S_SETHALT
9111
9112     class Inst_SOPP__S_SLEEP : public Inst_SOPP
9113     {
9114       public:
9115         Inst_SOPP__S_SLEEP(InFmt_SOPP*);
9116         ~Inst_SOPP__S_SLEEP();
9117
9118         int
9119         getNumOperands() override
9120         {
9121             return numDstRegOperands() + numSrcRegOperands();
9122         } // getNumOperands
9123
9124         int numDstRegOperands() override { return 0; }
9125         int numSrcRegOperands() override { return 1; }
9126
9127         int
9128         getOperandSize(int opIdx) override
9129         {
9130             switch (opIdx) {
9131               case 0: //simm16
9132                 return 2;
9133               default:
9134                 fatal("op idx %i out of bounds\n", opIdx);
9135                 return -1;
9136             }
9137         } // getOperandSize
9138
9139         bool
9140         isSrcOperand(int opIdx) override
9141         {
9142             switch (opIdx) {
9143               case 0: //simm16
9144                 return true;
9145               default:
9146                 fatal("op idx %i out of bounds\n", opIdx);
9147                 return false;
9148             }
9149         } // isSrcOperand
9150
9151         bool
9152         isDstOperand(int opIdx) override
9153         {
9154             switch (opIdx) {
9155               case 0: //simm16
9156                 return false;
9157               default:
9158                 fatal("op idx %i out of bounds\n", opIdx);
9159                 return false;
9160             }
9161         } // isDstOperand
9162
9163         void execute(GPUDynInstPtr) override;
9164     }; // Inst_SOPP__S_SLEEP
9165
9166     class Inst_SOPP__S_SETPRIO : public Inst_SOPP
9167     {
9168       public:
9169         Inst_SOPP__S_SETPRIO(InFmt_SOPP*);
9170         ~Inst_SOPP__S_SETPRIO();
9171
9172         int
9173         getNumOperands() override
9174         {
9175             return numDstRegOperands() + numSrcRegOperands();
9176         } // getNumOperands
9177
9178         int numDstRegOperands() override { return 0; }
9179         int numSrcRegOperands() override { return 1; }
9180
9181         int
9182         getOperandSize(int opIdx) override
9183         {
9184             switch (opIdx) {
9185               case 0: //simm16
9186                 return 2;
9187               default:
9188                 fatal("op idx %i out of bounds\n", opIdx);
9189                 return -1;
9190             }
9191         } // getOperandSize
9192
9193         bool
9194         isSrcOperand(int opIdx) override
9195         {
9196             switch (opIdx) {
9197               case 0: //simm16
9198                 return true;
9199               default:
9200                 fatal("op idx %i out of bounds\n", opIdx);
9201                 return false;
9202             }
9203         } // isSrcOperand
9204
9205         bool
9206         isDstOperand(int opIdx) override
9207         {
9208             switch (opIdx) {
9209               case 0: //simm16
9210                 return false;
9211               default:
9212                 fatal("op idx %i out of bounds\n", opIdx);
9213                 return false;
9214             }
9215         } // isDstOperand
9216
9217         void execute(GPUDynInstPtr) override;
9218     }; // Inst_SOPP__S_SETPRIO
9219
9220     class Inst_SOPP__S_SENDMSG : public Inst_SOPP
9221     {
9222       public:
9223         Inst_SOPP__S_SENDMSG(InFmt_SOPP*);
9224         ~Inst_SOPP__S_SENDMSG();
9225
9226         int
9227         getNumOperands() override
9228         {
9229             return numDstRegOperands() + numSrcRegOperands();
9230         } // getNumOperands
9231
9232         int numDstRegOperands() override { return 0; }
9233         int numSrcRegOperands() override { return 1; }
9234
9235         int
9236         getOperandSize(int opIdx) override
9237         {
9238             switch (opIdx) {
9239               case 0: //simm16
9240                 return 2;
9241               default:
9242                 fatal("op idx %i out of bounds\n", opIdx);
9243                 return -1;
9244             }
9245         } // getOperandSize
9246
9247         bool
9248         isSrcOperand(int opIdx) override
9249         {
9250             switch (opIdx) {
9251               case 0: //simm16
9252                 return true;
9253               default:
9254                 fatal("op idx %i out of bounds\n", opIdx);
9255                 return false;
9256             }
9257         } // isSrcOperand
9258
9259         bool
9260         isDstOperand(int opIdx) override
9261         {
9262             switch (opIdx) {
9263               case 0: //simm16
9264                 return false;
9265               default:
9266                 fatal("op idx %i out of bounds\n", opIdx);
9267                 return false;
9268             }
9269         } // isDstOperand
9270
9271         void execute(GPUDynInstPtr) override;
9272     }; // Inst_SOPP__S_SENDMSG
9273
9274     class Inst_SOPP__S_SENDMSGHALT : public Inst_SOPP
9275     {
9276       public:
9277         Inst_SOPP__S_SENDMSGHALT(InFmt_SOPP*);
9278         ~Inst_SOPP__S_SENDMSGHALT();
9279
9280         int
9281         getNumOperands() override
9282         {
9283             return numDstRegOperands() + numSrcRegOperands();
9284         } // getNumOperands
9285
9286         int numDstRegOperands() override { return 0; }
9287         int numSrcRegOperands() override { return 1; }
9288
9289         int
9290         getOperandSize(int opIdx) override
9291         {
9292             switch (opIdx) {
9293               case 0: //simm16
9294                 return 2;
9295               default:
9296                 fatal("op idx %i out of bounds\n", opIdx);
9297                 return -1;
9298             }
9299         } // getOperandSize
9300
9301         bool
9302         isSrcOperand(int opIdx) override
9303         {
9304             switch (opIdx) {
9305               case 0: //simm16
9306                 return true;
9307               default:
9308                 fatal("op idx %i out of bounds\n", opIdx);
9309                 return false;
9310             }
9311         } // isSrcOperand
9312
9313         bool
9314         isDstOperand(int opIdx) override
9315         {
9316             switch (opIdx) {
9317               case 0: //simm16
9318                 return false;
9319               default:
9320                 fatal("op idx %i out of bounds\n", opIdx);
9321                 return false;
9322             }
9323         } // isDstOperand
9324
9325         void execute(GPUDynInstPtr) override;
9326     }; // Inst_SOPP__S_SENDMSGHALT
9327
9328     class Inst_SOPP__S_TRAP : public Inst_SOPP
9329     {
9330       public:
9331         Inst_SOPP__S_TRAP(InFmt_SOPP*);
9332         ~Inst_SOPP__S_TRAP();
9333
9334         int
9335         getNumOperands() override
9336         {
9337             return numDstRegOperands() + numSrcRegOperands();
9338         } // getNumOperands
9339
9340         int numDstRegOperands() override { return 0; }
9341         int numSrcRegOperands() override { return 1; }
9342
9343         int
9344         getOperandSize(int opIdx) override
9345         {
9346             switch (opIdx) {
9347               case 0: //simm16
9348                 return 2;
9349               default:
9350                 fatal("op idx %i out of bounds\n", opIdx);
9351                 return -1;
9352             }
9353         } // getOperandSize
9354
9355         bool
9356         isSrcOperand(int opIdx) override
9357         {
9358             switch (opIdx) {
9359               case 0: //simm16
9360                 return true;
9361               default:
9362                 fatal("op idx %i out of bounds\n", opIdx);
9363                 return false;
9364             }
9365         } // isSrcOperand
9366
9367         bool
9368         isDstOperand(int opIdx) override
9369         {
9370             switch (opIdx) {
9371               case 0: //simm16
9372                 return false;
9373               default:
9374                 fatal("op idx %i out of bounds\n", opIdx);
9375                 return false;
9376             }
9377         } // isDstOperand
9378
9379         void execute(GPUDynInstPtr) override;
9380     }; // Inst_SOPP__S_TRAP
9381
9382     class Inst_SOPP__S_ICACHE_INV : public Inst_SOPP
9383     {
9384       public:
9385         Inst_SOPP__S_ICACHE_INV(InFmt_SOPP*);
9386         ~Inst_SOPP__S_ICACHE_INV();
9387
9388         int
9389         getNumOperands() override
9390         {
9391             return numDstRegOperands() + numSrcRegOperands();
9392         } // getNumOperands
9393
9394         int numDstRegOperands() override { return 0; }
9395         int numSrcRegOperands() override { return 0; }
9396
9397         int
9398         getOperandSize(int opIdx) override
9399         {
9400             switch (opIdx) {
9401               case 0: //simm16
9402                 return 2;
9403               default:
9404                 fatal("op idx %i out of bounds\n", opIdx);
9405                 return -1;
9406             }
9407         } // getOperandSize
9408
9409         bool
9410         isSrcOperand(int opIdx) override
9411         {
9412             switch (opIdx) {
9413               case 0: //simm16
9414                 return true;
9415               default:
9416                 fatal("op idx %i out of bounds\n", opIdx);
9417                 return false;
9418             }
9419         } // isSrcOperand
9420
9421         bool
9422         isDstOperand(int opIdx) override
9423         {
9424             switch (opIdx) {
9425               case 0: //simm16
9426                 return false;
9427               default:
9428                 fatal("op idx %i out of bounds\n", opIdx);
9429                 return false;
9430             }
9431         } // isDstOperand
9432
9433         void execute(GPUDynInstPtr) override;
9434     }; // Inst_SOPP__S_ICACHE_INV
9435
9436     class Inst_SOPP__S_INCPERFLEVEL : public Inst_SOPP
9437     {
9438       public:
9439         Inst_SOPP__S_INCPERFLEVEL(InFmt_SOPP*);
9440         ~Inst_SOPP__S_INCPERFLEVEL();
9441
9442         int
9443         getNumOperands() override
9444         {
9445             return numDstRegOperands() + numSrcRegOperands();
9446         } // getNumOperands
9447
9448         int numDstRegOperands() override { return 0; }
9449         int numSrcRegOperands() override { return 1; }
9450
9451         int
9452         getOperandSize(int opIdx) override
9453         {
9454             switch (opIdx) {
9455               case 0: //simm16
9456                 return 2;
9457               default:
9458                 fatal("op idx %i out of bounds\n", opIdx);
9459                 return -1;
9460             }
9461         } // getOperandSize
9462
9463         bool
9464         isSrcOperand(int opIdx) override
9465         {
9466             switch (opIdx) {
9467               case 0: //simm16
9468                 return true;
9469               default:
9470                 fatal("op idx %i out of bounds\n", opIdx);
9471                 return false;
9472             }
9473         } // isSrcOperand
9474
9475         bool
9476         isDstOperand(int opIdx) override
9477         {
9478             switch (opIdx) {
9479               case 0: //simm16
9480                 return false;
9481               default:
9482                 fatal("op idx %i out of bounds\n", opIdx);
9483                 return false;
9484             }
9485         } // isDstOperand
9486
9487         void execute(GPUDynInstPtr) override;
9488     }; // Inst_SOPP__S_INCPERFLEVEL
9489
9490     class Inst_SOPP__S_DECPERFLEVEL : public Inst_SOPP
9491     {
9492       public:
9493         Inst_SOPP__S_DECPERFLEVEL(InFmt_SOPP*);
9494         ~Inst_SOPP__S_DECPERFLEVEL();
9495
9496         int
9497         getNumOperands() override
9498         {
9499             return numDstRegOperands() + numSrcRegOperands();
9500         } // getNumOperands
9501
9502         int numDstRegOperands() override { return 0; }
9503         int numSrcRegOperands() override { return 1; }
9504
9505         int
9506         getOperandSize(int opIdx) override
9507         {
9508             switch (opIdx) {
9509               case 0: //simm16
9510                 return 2;
9511               default:
9512                 fatal("op idx %i out of bounds\n", opIdx);
9513                 return -1;
9514             }
9515         } // getOperandSize
9516
9517         bool
9518         isSrcOperand(int opIdx) override
9519         {
9520             switch (opIdx) {
9521               case 0: //simm16
9522                 return true;
9523               default:
9524                 fatal("op idx %i out of bounds\n", opIdx);
9525                 return false;
9526             }
9527         } // isSrcOperand
9528
9529         bool
9530         isDstOperand(int opIdx) override
9531         {
9532             switch (opIdx) {
9533               case 0: //simm16
9534                 return false;
9535               default:
9536                 fatal("op idx %i out of bounds\n", opIdx);
9537                 return false;
9538             }
9539         } // isDstOperand
9540
9541         void execute(GPUDynInstPtr) override;
9542     }; // Inst_SOPP__S_DECPERFLEVEL
9543
9544     class Inst_SOPP__S_TTRACEDATA : public Inst_SOPP
9545     {
9546       public:
9547         Inst_SOPP__S_TTRACEDATA(InFmt_SOPP*);
9548         ~Inst_SOPP__S_TTRACEDATA();
9549
9550         int
9551         getNumOperands() override
9552         {
9553             return numDstRegOperands() + numSrcRegOperands();
9554         } // getNumOperands
9555
9556         int numDstRegOperands() override { return 0; }
9557         int numSrcRegOperands() override { return 0; }
9558
9559         int
9560         getOperandSize(int opIdx) override
9561         {
9562             switch (opIdx) {
9563               case 0: //simm16
9564                 return 2;
9565               default:
9566                 fatal("op idx %i out of bounds\n", opIdx);
9567                 return -1;
9568             }
9569         } // getOperandSize
9570
9571         bool
9572         isSrcOperand(int opIdx) override
9573         {
9574             switch (opIdx) {
9575               case 0: //simm16
9576                 return true;
9577               default:
9578                 fatal("op idx %i out of bounds\n", opIdx);
9579                 return false;
9580             }
9581         } // isSrcOperand
9582
9583         bool
9584         isDstOperand(int opIdx) override
9585         {
9586             switch (opIdx) {
9587               case 0: //simm16
9588                 return false;
9589               default:
9590                 fatal("op idx %i out of bounds\n", opIdx);
9591                 return false;
9592             }
9593         } // isDstOperand
9594
9595         void execute(GPUDynInstPtr) override;
9596     }; // Inst_SOPP__S_TTRACEDATA
9597
9598     class Inst_SOPP__S_CBRANCH_CDBGSYS : public Inst_SOPP
9599     {
9600       public:
9601         Inst_SOPP__S_CBRANCH_CDBGSYS(InFmt_SOPP*);
9602         ~Inst_SOPP__S_CBRANCH_CDBGSYS();
9603
9604         int
9605         getNumOperands() override
9606         {
9607             return numDstRegOperands() + numSrcRegOperands();
9608         } // getNumOperands
9609
9610         int numDstRegOperands() override { return 0; }
9611         int numSrcRegOperands() override { return 1; }
9612
9613         int
9614         getOperandSize(int opIdx) override
9615         {
9616             switch (opIdx) {
9617               case 0: //label
9618                 return 2;
9619               default:
9620                 fatal("op idx %i out of bounds\n", opIdx);
9621                 return -1;
9622             }
9623         } // getOperandSize
9624
9625         bool
9626         isSrcOperand(int opIdx) override
9627         {
9628             switch (opIdx) {
9629               case 0: //label
9630                 return true;
9631               default:
9632                 fatal("op idx %i out of bounds\n", opIdx);
9633                 return false;
9634             }
9635         } // isSrcOperand
9636
9637         bool
9638         isDstOperand(int opIdx) override
9639         {
9640             switch (opIdx) {
9641               case 0: //label
9642                 return false;
9643               default:
9644                 fatal("op idx %i out of bounds\n", opIdx);
9645                 return false;
9646             }
9647         } // isDstOperand
9648
9649         void execute(GPUDynInstPtr) override;
9650     }; // Inst_SOPP__S_CBRANCH_CDBGSYS
9651
9652     class Inst_SOPP__S_CBRANCH_CDBGUSER : public Inst_SOPP
9653     {
9654       public:
9655         Inst_SOPP__S_CBRANCH_CDBGUSER(InFmt_SOPP*);
9656         ~Inst_SOPP__S_CBRANCH_CDBGUSER();
9657
9658         int
9659         getNumOperands() override
9660         {
9661             return numDstRegOperands() + numSrcRegOperands();
9662         } // getNumOperands
9663
9664         int numDstRegOperands() override { return 0; }
9665         int numSrcRegOperands() override { return 1; }
9666
9667         int
9668         getOperandSize(int opIdx) override
9669         {
9670             switch (opIdx) {
9671               case 0: //label
9672                 return 2;
9673               default:
9674                 fatal("op idx %i out of bounds\n", opIdx);
9675                 return -1;
9676             }
9677         } // getOperandSize
9678
9679         bool
9680         isSrcOperand(int opIdx) override
9681         {
9682             switch (opIdx) {
9683               case 0: //label
9684                 return true;
9685               default:
9686                 fatal("op idx %i out of bounds\n", opIdx);
9687                 return false;
9688             }
9689         } // isSrcOperand
9690
9691         bool
9692         isDstOperand(int opIdx) override
9693         {
9694             switch (opIdx) {
9695               case 0: //label
9696                 return false;
9697               default:
9698                 fatal("op idx %i out of bounds\n", opIdx);
9699                 return false;
9700             }
9701         } // isDstOperand
9702
9703         void execute(GPUDynInstPtr) override;
9704     }; // Inst_SOPP__S_CBRANCH_CDBGUSER
9705
9706     class Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER : public Inst_SOPP
9707     {
9708       public:
9709         Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER(InFmt_SOPP*);
9710         ~Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER();
9711
9712         int
9713         getNumOperands() override
9714         {
9715             return numDstRegOperands() + numSrcRegOperands();
9716         } // getNumOperands
9717
9718         int numDstRegOperands() override { return 0; }
9719         int numSrcRegOperands() override { return 1; }
9720
9721         int
9722         getOperandSize(int opIdx) override
9723         {
9724             switch (opIdx) {
9725               case 0: //label
9726                 return 2;
9727               default:
9728                 fatal("op idx %i out of bounds\n", opIdx);
9729                 return -1;
9730             }
9731         } // getOperandSize
9732
9733         bool
9734         isSrcOperand(int opIdx) override
9735         {
9736             switch (opIdx) {
9737               case 0: //label
9738                 return true;
9739               default:
9740                 fatal("op idx %i out of bounds\n", opIdx);
9741                 return false;
9742             }
9743         } // isSrcOperand
9744
9745         bool
9746         isDstOperand(int opIdx) override
9747         {
9748             switch (opIdx) {
9749               case 0: //label
9750                 return false;
9751               default:
9752                 fatal("op idx %i out of bounds\n", opIdx);
9753                 return false;
9754             }
9755         } // isDstOperand
9756
9757         void execute(GPUDynInstPtr) override;
9758     }; // Inst_SOPP__S_CBRANCH_CDBGSYS_OR_USER
9759
9760     class Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER : public Inst_SOPP
9761     {
9762       public:
9763         Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER(InFmt_SOPP*);
9764         ~Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER();
9765
9766         int
9767         getNumOperands() override
9768         {
9769             return numDstRegOperands() + numSrcRegOperands();
9770         } // getNumOperands
9771
9772         int numDstRegOperands() override { return 0; }
9773         int numSrcRegOperands() override { return 1; }
9774
9775         int
9776         getOperandSize(int opIdx) override
9777         {
9778             switch (opIdx) {
9779               case 0: //label
9780                 return 2;
9781               default:
9782                 fatal("op idx %i out of bounds\n", opIdx);
9783                 return -1;
9784             }
9785         } // getOperandSize
9786
9787         bool
9788         isSrcOperand(int opIdx) override
9789         {
9790             switch (opIdx) {
9791               case 0: //label
9792                 return true;
9793               default:
9794                 fatal("op idx %i out of bounds\n", opIdx);
9795                 return false;
9796             }
9797         } // isSrcOperand
9798
9799         bool
9800         isDstOperand(int opIdx) override
9801         {
9802             switch (opIdx) {
9803               case 0: //label
9804                 return false;
9805               default:
9806                 fatal("op idx %i out of bounds\n", opIdx);
9807                 return false;
9808             }
9809         } // isDstOperand
9810
9811         void execute(GPUDynInstPtr) override;
9812     }; // Inst_SOPP__S_CBRANCH_CDBGSYS_AND_USER
9813
9814     class Inst_SOPP__S_ENDPGM_SAVED : public Inst_SOPP
9815     {
9816       public:
9817         Inst_SOPP__S_ENDPGM_SAVED(InFmt_SOPP*);
9818         ~Inst_SOPP__S_ENDPGM_SAVED();
9819
9820         int
9821         getNumOperands() override
9822         {
9823             return numDstRegOperands() + numSrcRegOperands();
9824         } // getNumOperands
9825
9826         int numDstRegOperands() override { return 0; }
9827         int numSrcRegOperands() override { return 0; }
9828
9829         int
9830         getOperandSize(int opIdx) override
9831         {
9832             switch (opIdx) {
9833               case 0: //simm16
9834                 return 2;
9835               default:
9836                 fatal("op idx %i out of bounds\n", opIdx);
9837                 return -1;
9838             }
9839         } // getOperandSize
9840
9841         bool
9842         isSrcOperand(int opIdx) override
9843         {
9844             switch (opIdx) {
9845               case 0: //simm16
9846                 return true;
9847               default:
9848                 fatal("op idx %i out of bounds\n", opIdx);
9849                 return false;
9850             }
9851         } // isSrcOperand
9852
9853         bool
9854         isDstOperand(int opIdx) override
9855         {
9856             switch (opIdx) {
9857               case 0: //simm16
9858                 return false;
9859               default:
9860                 fatal("op idx %i out of bounds\n", opIdx);
9861                 return false;
9862             }
9863         } // isDstOperand
9864
9865         void execute(GPUDynInstPtr) override;
9866     }; // Inst_SOPP__S_ENDPGM_SAVED
9867
9868     class Inst_SOPP__S_SET_GPR_IDX_OFF : public Inst_SOPP
9869     {
9870       public:
9871         Inst_SOPP__S_SET_GPR_IDX_OFF(InFmt_SOPP*);
9872         ~Inst_SOPP__S_SET_GPR_IDX_OFF();
9873
9874         int
9875         getNumOperands() override
9876         {
9877             return numDstRegOperands() + numSrcRegOperands();
9878         } // getNumOperands
9879
9880         int numDstRegOperands() override { return 0; }
9881         int numSrcRegOperands() override { return 0; }
9882
9883         int
9884         getOperandSize(int opIdx) override
9885         {
9886             switch (opIdx) {
9887               case 0: //simm16
9888                 return 2;
9889               default:
9890                 fatal("op idx %i out of bounds\n", opIdx);
9891                 return -1;
9892             }
9893         } // getOperandSize
9894
9895         bool
9896         isSrcOperand(int opIdx) override
9897         {
9898             switch (opIdx) {
9899               case 0: //simm16
9900                 return true;
9901               default:
9902                 fatal("op idx %i out of bounds\n", opIdx);
9903                 return false;
9904             }
9905         } // isSrcOperand
9906
9907         bool
9908         isDstOperand(int opIdx) override
9909         {
9910             switch (opIdx) {
9911               case 0: //simm16
9912                 return false;
9913               default:
9914                 fatal("op idx %i out of bounds\n", opIdx);
9915                 return false;
9916             }
9917         } // isDstOperand
9918
9919         void execute(GPUDynInstPtr) override;
9920     }; // Inst_SOPP__S_SET_GPR_IDX_OFF
9921
9922     class Inst_SOPP__S_SET_GPR_IDX_MODE : public Inst_SOPP
9923     {
9924       public:
9925         Inst_SOPP__S_SET_GPR_IDX_MODE(InFmt_SOPP*);
9926         ~Inst_SOPP__S_SET_GPR_IDX_MODE();
9927
9928         int
9929         getNumOperands() override
9930         {
9931             return numDstRegOperands() + numSrcRegOperands();
9932         } // getNumOperands
9933
9934         int numDstRegOperands() override { return 0; }
9935         int numSrcRegOperands() override { return 1; }
9936
9937         int
9938         getOperandSize(int opIdx) override
9939         {
9940             switch (opIdx) {
9941               case 0: //simm16
9942                 return 2;
9943               default:
9944                 fatal("op idx %i out of bounds\n", opIdx);
9945                 return -1;
9946             }
9947         } // getOperandSize
9948
9949         bool
9950         isSrcOperand(int opIdx) override
9951         {
9952             switch (opIdx) {
9953               case 0: //simm16
9954                 return true;
9955               default:
9956                 fatal("op idx %i out of bounds\n", opIdx);
9957                 return false;
9958             }
9959         } // isSrcOperand
9960
9961         bool
9962         isDstOperand(int opIdx) override
9963         {
9964             switch (opIdx) {
9965               case 0: //simm16
9966                 return false;
9967               default:
9968                 fatal("op idx %i out of bounds\n", opIdx);
9969                 return false;
9970             }
9971         } // isDstOperand
9972
9973         void execute(GPUDynInstPtr) override;
9974     }; // Inst_SOPP__S_SET_GPR_IDX_MODE
9975
9976     class Inst_SMEM__S_LOAD_DWORD : public Inst_SMEM
9977     {
9978       public:
9979         Inst_SMEM__S_LOAD_DWORD(InFmt_SMEM*);
9980         ~Inst_SMEM__S_LOAD_DWORD();
9981
9982         int
9983         getNumOperands() override
9984         {
9985             return numDstRegOperands() + numSrcRegOperands();
9986         } // getNumOperands
9987
9988         int numDstRegOperands() override { return 1; }
9989         int numSrcRegOperands() override { return 2; }
9990
9991         int
9992         getOperandSize(int opIdx) override
9993         {
9994             switch (opIdx) {
9995               case 0: //sgpr_base
9996                 return 8;
9997               case 1: //offset
9998                 return 4;
9999               case 2: //sgpr_dst
10000                 return 4;
10001               default:
10002                 fatal("op idx %i out of bounds\n", opIdx);
10003                 return -1;
10004             }
10005         } // getOperandSize
10006
10007         bool
10008         isSrcOperand(int opIdx) override
10009         {
10010             switch (opIdx) {
10011               case 0: //sgpr_base
10012                 return true;
10013               case 1: //offset
10014                 return true;
10015               case 2: //sgpr_dst
10016                 return false;
10017               default:
10018                 fatal("op idx %i out of bounds\n", opIdx);
10019                 return false;
10020             }
10021         } // isSrcOperand
10022
10023         bool
10024         isDstOperand(int opIdx) override
10025         {
10026             switch (opIdx) {
10027               case 0: //sgpr_base
10028                 return false;
10029               case 1: //offset
10030                 return false;
10031               case 2: //sgpr_dst
10032                 return true;
10033               default:
10034                 fatal("op idx %i out of bounds\n", opIdx);
10035                 return false;
10036             }
10037         } // isDstOperand
10038
10039         void execute(GPUDynInstPtr) override;
10040         void initiateAcc(GPUDynInstPtr) override;
10041         void completeAcc(GPUDynInstPtr) override;
10042     }; // Inst_SMEM__S_LOAD_DWORD
10043
10044     class Inst_SMEM__S_LOAD_DWORDX2 : public Inst_SMEM
10045     {
10046       public:
10047         Inst_SMEM__S_LOAD_DWORDX2(InFmt_SMEM*);
10048         ~Inst_SMEM__S_LOAD_DWORDX2();
10049
10050         int
10051         getNumOperands() override
10052         {
10053             return numDstRegOperands() + numSrcRegOperands();
10054         } // getNumOperands
10055
10056         int numDstRegOperands() override { return 1; }
10057         int numSrcRegOperands() override { return 2; }
10058
10059         int
10060         getOperandSize(int opIdx) override
10061         {
10062             switch (opIdx) {
10063               case 0: //sgpr_base
10064                 return 8;
10065               case 1: //offset
10066                 return 4;
10067               case 2: //sgpr_dst
10068                 return 8;
10069               default:
10070                 fatal("op idx %i out of bounds\n", opIdx);
10071                 return -1;
10072             }
10073         } // getOperandSize
10074
10075         bool
10076         isSrcOperand(int opIdx) override
10077         {
10078             switch (opIdx) {
10079               case 0: //sgpr_base
10080                 return true;
10081               case 1: //offset
10082                 return true;
10083               case 2: //sgpr_dst
10084                 return false;
10085               default:
10086                 fatal("op idx %i out of bounds\n", opIdx);
10087                 return false;
10088             }
10089         } // isSrcOperand
10090
10091         bool
10092         isDstOperand(int opIdx) override
10093         {
10094             switch (opIdx) {
10095               case 0: //sgpr_base
10096                 return false;
10097               case 1: //offset
10098                 return false;
10099               case 2: //sgpr_dst
10100                 return true;
10101               default:
10102                 fatal("op idx %i out of bounds\n", opIdx);
10103                 return false;
10104             }
10105         } // isDstOperand
10106
10107         void execute(GPUDynInstPtr) override;
10108         void initiateAcc(GPUDynInstPtr) override;
10109         void completeAcc(GPUDynInstPtr) override;
10110     }; // Inst_SMEM__S_LOAD_DWORDX2
10111
10112     class Inst_SMEM__S_LOAD_DWORDX4 : public Inst_SMEM
10113     {
10114       public:
10115         Inst_SMEM__S_LOAD_DWORDX4(InFmt_SMEM*);
10116         ~Inst_SMEM__S_LOAD_DWORDX4();
10117
10118         int
10119         getNumOperands() override
10120         {
10121             return numDstRegOperands() + numSrcRegOperands();
10122         } // getNumOperands
10123
10124         int numDstRegOperands() override { return 1; }
10125         int numSrcRegOperands() override { return 2; }
10126
10127         int
10128         getOperandSize(int opIdx) override
10129         {
10130             switch (opIdx) {
10131               case 0: //sgpr_base
10132                 return 8;
10133               case 1: //offset
10134                 return 4;
10135               case 2: //sgpr_dst
10136                 return 16;
10137               default:
10138                 fatal("op idx %i out of bounds\n", opIdx);
10139                 return -1;
10140             }
10141         } // getOperandSize
10142
10143         bool
10144         isSrcOperand(int opIdx) override
10145         {
10146             switch (opIdx) {
10147               case 0: //sgpr_base
10148                 return true;
10149               case 1: //offset
10150                 return true;
10151               case 2: //sgpr_dst
10152                 return false;
10153               default:
10154                 fatal("op idx %i out of bounds\n", opIdx);
10155                 return false;
10156             }
10157         } // isSrcOperand
10158
10159         bool
10160         isDstOperand(int opIdx) override
10161         {
10162             switch (opIdx) {
10163               case 0: //sgpr_base
10164                 return false;
10165               case 1: //offset
10166                 return false;
10167               case 2: //sgpr_dst
10168                 return true;
10169               default:
10170                 fatal("op idx %i out of bounds\n", opIdx);
10171                 return false;
10172             }
10173         } // isDstOperand
10174
10175         void execute(GPUDynInstPtr) override;
10176         void initiateAcc(GPUDynInstPtr) override;
10177         void completeAcc(GPUDynInstPtr) override;
10178     }; // Inst_SMEM__S_LOAD_DWORDX4
10179
10180     class Inst_SMEM__S_LOAD_DWORDX8 : public Inst_SMEM
10181     {
10182       public:
10183         Inst_SMEM__S_LOAD_DWORDX8(InFmt_SMEM*);
10184         ~Inst_SMEM__S_LOAD_DWORDX8();
10185
10186         int
10187         getNumOperands() override
10188         {
10189             return numDstRegOperands() + numSrcRegOperands();
10190         } // getNumOperands
10191
10192         int numDstRegOperands() override { return 1; }
10193         int numSrcRegOperands() override { return 2; }
10194
10195         int
10196         getOperandSize(int opIdx) override
10197         {
10198             switch (opIdx) {
10199               case 0: //sgpr_base
10200                 return 8;
10201               case 1: //offset
10202                 return 4;
10203               case 2: //sgpr_dst
10204                 return 32;
10205               default:
10206                 fatal("op idx %i out of bounds\n", opIdx);
10207                 return -1;
10208             }
10209         } // getOperandSize
10210
10211         bool
10212         isSrcOperand(int opIdx) override
10213         {
10214             switch (opIdx) {
10215               case 0: //sgpr_base
10216                 return true;
10217               case 1: //offset
10218                 return true;
10219               case 2: //sgpr_dst
10220                 return false;
10221               default:
10222                 fatal("op idx %i out of bounds\n", opIdx);
10223                 return false;
10224             }
10225         } // isSrcOperand
10226
10227         bool
10228         isDstOperand(int opIdx) override
10229         {
10230             switch (opIdx) {
10231               case 0: //sgpr_base
10232                 return false;
10233               case 1: //offset
10234                 return false;
10235               case 2: //sgpr_dst
10236                 return true;
10237               default:
10238                 fatal("op idx %i out of bounds\n", opIdx);
10239                 return false;
10240             }
10241         } // isDstOperand
10242
10243         void execute(GPUDynInstPtr) override;
10244         void initiateAcc(GPUDynInstPtr) override;
10245         void completeAcc(GPUDynInstPtr) override;
10246     }; // Inst_SMEM__S_LOAD_DWORDX8
10247
10248     class Inst_SMEM__S_LOAD_DWORDX16 : public Inst_SMEM
10249     {
10250       public:
10251         Inst_SMEM__S_LOAD_DWORDX16(InFmt_SMEM*);
10252         ~Inst_SMEM__S_LOAD_DWORDX16();
10253
10254         int
10255         getNumOperands() override
10256         {
10257             return numDstRegOperands() + numSrcRegOperands();
10258         } // getNumOperands
10259
10260         int numDstRegOperands() override { return 1; }
10261         int numSrcRegOperands() override { return 2; }
10262
10263         int
10264         getOperandSize(int opIdx) override
10265         {
10266             switch (opIdx) {
10267               case 0: //sgpr_base
10268                 return 8;
10269               case 1: //offset
10270                 return 4;
10271               case 2: //sgpr_dst
10272                 return 64;
10273               default:
10274                 fatal("op idx %i out of bounds\n", opIdx);
10275                 return -1;
10276             }
10277         } // getOperandSize
10278
10279         bool
10280         isSrcOperand(int opIdx) override
10281         {
10282             switch (opIdx) {
10283               case 0: //sgpr_base
10284                 return true;
10285               case 1: //offset
10286                 return true;
10287               case 2: //sgpr_dst
10288                 return false;
10289               default:
10290                 fatal("op idx %i out of bounds\n", opIdx);
10291                 return false;
10292             }
10293         } // isSrcOperand
10294
10295         bool
10296         isDstOperand(int opIdx) override
10297         {
10298             switch (opIdx) {
10299               case 0: //sgpr_base
10300                 return false;
10301               case 1: //offset
10302                 return false;
10303               case 2: //sgpr_dst
10304                 return true;
10305               default:
10306                 fatal("op idx %i out of bounds\n", opIdx);
10307                 return false;
10308             }
10309         } // isDstOperand
10310
10311         void execute(GPUDynInstPtr) override;
10312         void initiateAcc(GPUDynInstPtr) override;
10313         void completeAcc(GPUDynInstPtr) override;
10314     }; // Inst_SMEM__S_LOAD_DWORDX16
10315
10316     class Inst_SMEM__S_BUFFER_LOAD_DWORD : public Inst_SMEM
10317     {
10318       public:
10319         Inst_SMEM__S_BUFFER_LOAD_DWORD(InFmt_SMEM*);
10320         ~Inst_SMEM__S_BUFFER_LOAD_DWORD();
10321
10322         int
10323         getNumOperands() override
10324         {
10325             return numDstRegOperands() + numSrcRegOperands();
10326         } // getNumOperands
10327
10328         int numDstRegOperands() override { return 1; }
10329         int numSrcRegOperands() override { return 2; }
10330
10331         int
10332         getOperandSize(int opIdx) override
10333         {
10334             switch (opIdx) {
10335               case 0: //sgpr_base
10336                 return 16;
10337               case 1: //offset
10338                 return 4;
10339               case 2: //sgpr_dst
10340                 return 4;
10341               default:
10342                 fatal("op idx %i out of bounds\n", opIdx);
10343                 return -1;
10344             }
10345         } // getOperandSize
10346
10347         bool
10348         isSrcOperand(int opIdx) override
10349         {
10350             switch (opIdx) {
10351               case 0: //sgpr_base
10352                 return true;
10353               case 1: //offset
10354                 return true;
10355               case 2: //sgpr_dst
10356                 return false;
10357               default:
10358                 fatal("op idx %i out of bounds\n", opIdx);
10359                 return false;
10360             }
10361         } // isSrcOperand
10362
10363         bool
10364         isDstOperand(int opIdx) override
10365         {
10366             switch (opIdx) {
10367               case 0: //sgpr_base
10368                 return false;
10369               case 1: //offset
10370                 return false;
10371               case 2: //sgpr_dst
10372                 return true;
10373               default:
10374                 fatal("op idx %i out of bounds\n", opIdx);
10375                 return false;
10376             }
10377         } // isDstOperand
10378
10379         void execute(GPUDynInstPtr) override;
10380         void initiateAcc(GPUDynInstPtr) override;
10381         void completeAcc(GPUDynInstPtr) override;
10382     }; // Inst_SMEM__S_BUFFER_LOAD_DWORD
10383
10384     class Inst_SMEM__S_BUFFER_LOAD_DWORDX2 : public Inst_SMEM
10385     {
10386       public:
10387         Inst_SMEM__S_BUFFER_LOAD_DWORDX2(InFmt_SMEM*);
10388         ~Inst_SMEM__S_BUFFER_LOAD_DWORDX2();
10389
10390         int
10391         getNumOperands() override
10392         {
10393             return numDstRegOperands() + numSrcRegOperands();
10394         } // getNumOperands
10395
10396         int numDstRegOperands() override { return 1; }
10397         int numSrcRegOperands() override { return 2; }
10398
10399         int
10400         getOperandSize(int opIdx) override
10401         {
10402             switch (opIdx) {
10403               case 0: //sgpr_base
10404                 return 16;
10405               case 1: //offset
10406                 return 4;
10407               case 2: //sgpr_dst
10408                 return 8;
10409               default:
10410                 fatal("op idx %i out of bounds\n", opIdx);
10411                 return -1;
10412             }
10413         } // getOperandSize
10414
10415         bool
10416         isSrcOperand(int opIdx) override
10417         {
10418             switch (opIdx) {
10419               case 0: //sgpr_base
10420                 return true;
10421               case 1: //offset
10422                 return true;
10423               case 2: //sgpr_dst
10424                 return false;
10425               default:
10426                 fatal("op idx %i out of bounds\n", opIdx);
10427                 return false;
10428             }
10429         } // isSrcOperand
10430
10431         bool
10432         isDstOperand(int opIdx) override
10433         {
10434             switch (opIdx) {
10435               case 0: //sgpr_base
10436                 return false;
10437               case 1: //offset
10438                 return false;
10439               case 2: //sgpr_dst
10440                 return true;
10441               default:
10442                 fatal("op idx %i out of bounds\n", opIdx);
10443                 return false;
10444             }
10445         } // isDstOperand
10446
10447         void execute(GPUDynInstPtr) override;
10448         void initiateAcc(GPUDynInstPtr) override;
10449         void completeAcc(GPUDynInstPtr) override;
10450     }; // Inst_SMEM__S_BUFFER_LOAD_DWORDX2
10451
10452     class Inst_SMEM__S_BUFFER_LOAD_DWORDX4 : public Inst_SMEM
10453     {
10454       public:
10455         Inst_SMEM__S_BUFFER_LOAD_DWORDX4(InFmt_SMEM*);
10456         ~Inst_SMEM__S_BUFFER_LOAD_DWORDX4();
10457
10458         int
10459         getNumOperands() override
10460         {
10461             return numDstRegOperands() + numSrcRegOperands();
10462         } // getNumOperands
10463
10464         int numDstRegOperands() override { return 1; }
10465         int numSrcRegOperands() override { return 2; }
10466
10467         int
10468         getOperandSize(int opIdx) override
10469         {
10470             switch (opIdx) {
10471               case 0: //sgpr_base
10472                 return 16;
10473               case 1: //offset
10474                 return 4;
10475               case 2: //sgpr_dst
10476                 return 16;
10477               default:
10478                 fatal("op idx %i out of bounds\n", opIdx);
10479                 return -1;
10480             }
10481         } // getOperandSize
10482
10483         bool
10484         isSrcOperand(int opIdx) override
10485         {
10486             switch (opIdx) {
10487               case 0: //sgpr_base
10488                 return true;
10489               case 1: //offset
10490                 return true;
10491               case 2: //sgpr_dst
10492                 return false;
10493               default:
10494                 fatal("op idx %i out of bounds\n", opIdx);
10495                 return false;
10496             }
10497         } // isSrcOperand
10498
10499         bool
10500         isDstOperand(int opIdx) override
10501         {
10502             switch (opIdx) {
10503               case 0: //sgpr_base
10504                 return false;
10505               case 1: //offset
10506                 return false;
10507               case 2: //sgpr_dst
10508                 return true;
10509               default:
10510                 fatal("op idx %i out of bounds\n", opIdx);
10511                 return false;
10512             }
10513         } // isDstOperand
10514
10515         void execute(GPUDynInstPtr) override;
10516         void initiateAcc(GPUDynInstPtr) override;
10517         void completeAcc(GPUDynInstPtr) override;
10518     }; // Inst_SMEM__S_BUFFER_LOAD_DWORDX4
10519
10520     class Inst_SMEM__S_BUFFER_LOAD_DWORDX8 : public Inst_SMEM
10521     {
10522       public:
10523         Inst_SMEM__S_BUFFER_LOAD_DWORDX8(InFmt_SMEM*);
10524         ~Inst_SMEM__S_BUFFER_LOAD_DWORDX8();
10525
10526         int
10527         getNumOperands() override
10528         {
10529             return numDstRegOperands() + numSrcRegOperands();
10530         } // getNumOperands
10531
10532         int numDstRegOperands() override { return 1; }
10533         int numSrcRegOperands() override { return 2; }
10534
10535         int
10536         getOperandSize(int opIdx) override
10537         {
10538             switch (opIdx) {
10539               case 0: //sgpr_base
10540                 return 16;
10541               case 1: //offset
10542                 return 4;
10543               case 2: //sgpr_dst
10544                 return 32;
10545               default:
10546                 fatal("op idx %i out of bounds\n", opIdx);
10547                 return -1;
10548             }
10549         } // getOperandSize
10550
10551         bool
10552         isSrcOperand(int opIdx) override
10553         {
10554             switch (opIdx) {
10555               case 0: //sgpr_base
10556                 return true;
10557               case 1: //offset
10558                 return true;
10559               case 2: //sgpr_dst
10560                 return false;
10561               default:
10562                 fatal("op idx %i out of bounds\n", opIdx);
10563                 return false;
10564             }
10565         } // isSrcOperand
10566
10567         bool
10568         isDstOperand(int opIdx) override
10569         {
10570             switch (opIdx) {
10571               case 0: //sgpr_base
10572                 return false;
10573               case 1: //offset
10574                 return false;
10575               case 2: //sgpr_dst
10576                 return true;
10577               default:
10578                 fatal("op idx %i out of bounds\n", opIdx);
10579                 return false;
10580             }
10581         } // isDstOperand
10582
10583         void execute(GPUDynInstPtr) override;
10584         void initiateAcc(GPUDynInstPtr) override;
10585         void completeAcc(GPUDynInstPtr) override;
10586     }; // Inst_SMEM__S_BUFFER_LOAD_DWORDX8
10587
10588     class Inst_SMEM__S_BUFFER_LOAD_DWORDX16 : public Inst_SMEM
10589     {
10590       public:
10591         Inst_SMEM__S_BUFFER_LOAD_DWORDX16(InFmt_SMEM*);
10592         ~Inst_SMEM__S_BUFFER_LOAD_DWORDX16();
10593
10594         int
10595         getNumOperands() override
10596         {
10597             return numDstRegOperands() + numSrcRegOperands();
10598         } // getNumOperands
10599
10600         int numDstRegOperands() override { return 1; }
10601         int numSrcRegOperands() override { return 2; }
10602
10603         int
10604         getOperandSize(int opIdx) override
10605         {
10606             switch (opIdx) {
10607               case 0: //sgpr_base
10608                 return 16;
10609               case 1: //offset
10610                 return 4;
10611               case 2: //sgpr_dst
10612                 return 64;
10613               default:
10614                 fatal("op idx %i out of bounds\n", opIdx);
10615                 return -1;
10616             }
10617         } // getOperandSize
10618
10619         bool
10620         isSrcOperand(int opIdx) override
10621         {
10622             switch (opIdx) {
10623               case 0: //sgpr_base
10624                 return true;
10625               case 1: //offset
10626                 return true;
10627               case 2: //sgpr_dst
10628                 return false;
10629               default:
10630                 fatal("op idx %i out of bounds\n", opIdx);
10631                 return false;
10632             }
10633         } // isSrcOperand
10634
10635         bool
10636         isDstOperand(int opIdx) override
10637         {
10638             switch (opIdx) {
10639               case 0: //sgpr_base
10640                 return false;
10641               case 1: //offset
10642                 return false;
10643               case 2: //sgpr_dst
10644                 return true;
10645               default:
10646                 fatal("op idx %i out of bounds\n", opIdx);
10647                 return false;
10648             }
10649         } // isDstOperand
10650
10651         void execute(GPUDynInstPtr) override;
10652         void initiateAcc(GPUDynInstPtr) override;
10653         void completeAcc(GPUDynInstPtr) override;
10654     }; // Inst_SMEM__S_BUFFER_LOAD_DWORDX16
10655
10656     class Inst_SMEM__S_STORE_DWORD : public Inst_SMEM
10657     {
10658       public:
10659         Inst_SMEM__S_STORE_DWORD(InFmt_SMEM*);
10660         ~Inst_SMEM__S_STORE_DWORD();
10661
10662         int
10663         getNumOperands() override
10664         {
10665             return numDstRegOperands() + numSrcRegOperands();
10666         } // getNumOperands
10667
10668         int numDstRegOperands() override { return 0; }
10669         int numSrcRegOperands() override { return 3; }
10670
10671         int
10672         getOperandSize(int opIdx) override
10673         {
10674             switch (opIdx) {
10675               case 0: //sgpr_data
10676                 return 4;
10677               case 1: //sgpr_base
10678                 return 8;
10679               case 2: //offset
10680                 return 4;
10681               default:
10682                 fatal("op idx %i out of bounds\n", opIdx);
10683                 return -1;
10684             }
10685         } // getOperandSize
10686
10687         bool
10688         isSrcOperand(int opIdx) override
10689         {
10690             switch (opIdx) {
10691               case 0: //sgpr_data
10692                 return true;
10693               case 1: //sgpr_base
10694                 return true;
10695               case 2: //offset
10696                 return true;
10697               default:
10698                 fatal("op idx %i out of bounds\n", opIdx);
10699                 return false;
10700             }
10701         } // isSrcOperand
10702
10703         bool
10704         isDstOperand(int opIdx) override
10705         {
10706             switch (opIdx) {
10707               case 0: //sgpr_data
10708                 return false;
10709               case 1: //sgpr_base
10710                 return false;
10711               case 2: //offset
10712                 return false;
10713               default:
10714                 fatal("op idx %i out of bounds\n", opIdx);
10715                 return false;
10716             }
10717         } // isDstOperand
10718
10719         void execute(GPUDynInstPtr) override;
10720         void initiateAcc(GPUDynInstPtr) override;
10721         void completeAcc(GPUDynInstPtr) override;
10722     }; // Inst_SMEM__S_STORE_DWORD
10723
10724     class Inst_SMEM__S_STORE_DWORDX2 : public Inst_SMEM
10725     {
10726       public:
10727         Inst_SMEM__S_STORE_DWORDX2(InFmt_SMEM*);
10728         ~Inst_SMEM__S_STORE_DWORDX2();
10729
10730         int
10731         getNumOperands() override
10732         {
10733             return numDstRegOperands() + numSrcRegOperands();
10734         } // getNumOperands
10735
10736         int numDstRegOperands() override { return 0; }
10737         int numSrcRegOperands() override { return 3; }
10738
10739         int
10740         getOperandSize(int opIdx) override
10741         {
10742             switch (opIdx) {
10743               case 0: //sgpr_data
10744                 return 8;
10745               case 1: //sgpr_base
10746                 return 8;
10747               case 2: //offset
10748                 return 4;
10749               default:
10750                 fatal("op idx %i out of bounds\n", opIdx);
10751                 return -1;
10752             }
10753         } // getOperandSize
10754
10755         bool
10756         isSrcOperand(int opIdx) override
10757         {
10758             switch (opIdx) {
10759               case 0: //sgpr_data
10760                 return true;
10761               case 1: //sgpr_base
10762                 return true;
10763               case 2: //offset
10764                 return true;
10765               default:
10766                 fatal("op idx %i out of bounds\n", opIdx);
10767                 return false;
10768             }
10769         } // isSrcOperand
10770
10771         bool
10772         isDstOperand(int opIdx) override
10773         {
10774             switch (opIdx) {
10775               case 0: //sgpr_data
10776                 return false;
10777               case 1: //sgpr_base
10778                 return false;
10779               case 2: //offset
10780                 return false;
10781               default:
10782                 fatal("op idx %i out of bounds\n", opIdx);
10783                 return false;
10784             }
10785         } // isDstOperand
10786
10787         void execute(GPUDynInstPtr) override;
10788         void initiateAcc(GPUDynInstPtr) override;
10789         void completeAcc(GPUDynInstPtr) override;
10790     }; // Inst_SMEM__S_STORE_DWORDX2
10791
10792     class Inst_SMEM__S_STORE_DWORDX4 : public Inst_SMEM
10793     {
10794       public:
10795         Inst_SMEM__S_STORE_DWORDX4(InFmt_SMEM*);
10796         ~Inst_SMEM__S_STORE_DWORDX4();
10797
10798         int
10799         getNumOperands() override
10800         {
10801             return numDstRegOperands() + numSrcRegOperands();
10802         } // getNumOperands
10803
10804         int numDstRegOperands() override { return 0; }
10805         int numSrcRegOperands() override { return 3; }
10806
10807         int
10808         getOperandSize(int opIdx) override
10809         {
10810             switch (opIdx) {
10811               case 0: //sgpr_data
10812                 return 16;
10813               case 1: //sgpr_base
10814                 return 8;
10815               case 2: //offset
10816                 return 4;
10817               default:
10818                 fatal("op idx %i out of bounds\n", opIdx);
10819                 return -1;
10820             }
10821         } // getOperandSize
10822
10823         bool
10824         isSrcOperand(int opIdx) override
10825         {
10826             switch (opIdx) {
10827               case 0: //sgpr_data
10828                 return true;
10829               case 1: //sgpr_base
10830                 return true;
10831               case 2: //offset
10832                 return true;
10833               default:
10834                 fatal("op idx %i out of bounds\n", opIdx);
10835                 return false;
10836             }
10837         } // isSrcOperand
10838
10839         bool
10840         isDstOperand(int opIdx) override
10841         {
10842             switch (opIdx) {
10843               case 0: //sgpr_data
10844                 return false;
10845               case 1: //sgpr_base
10846                 return false;
10847               case 2: //offset
10848                 return false;
10849               default:
10850                 fatal("op idx %i out of bounds\n", opIdx);
10851                 return false;
10852             }
10853         } // isDstOperand
10854
10855         void execute(GPUDynInstPtr) override;
10856         void initiateAcc(GPUDynInstPtr) override;
10857         void completeAcc(GPUDynInstPtr) override;
10858     }; // Inst_SMEM__S_STORE_DWORDX4
10859
10860     class Inst_SMEM__S_BUFFER_STORE_DWORD : public Inst_SMEM
10861     {
10862       public:
10863         Inst_SMEM__S_BUFFER_STORE_DWORD(InFmt_SMEM*);
10864         ~Inst_SMEM__S_BUFFER_STORE_DWORD();
10865
10866         int
10867         getNumOperands() override
10868         {
10869             return numDstRegOperands() + numSrcRegOperands();
10870         } // getNumOperands
10871
10872         int numDstRegOperands() override { return 0; }
10873         int numSrcRegOperands() override { return 3; }
10874
10875         int
10876         getOperandSize(int opIdx) override
10877         {
10878             switch (opIdx) {
10879               case 0: //sgpr_data
10880                 return 4;
10881               case 1: //sgpr_base
10882                 return 16;
10883               case 2: //offset
10884                 return 4;
10885               default:
10886                 fatal("op idx %i out of bounds\n", opIdx);
10887                 return -1;
10888             }
10889         } // getOperandSize
10890
10891         bool
10892         isSrcOperand(int opIdx) override
10893         {
10894             switch (opIdx) {
10895               case 0: //sgpr_data
10896                 return true;
10897               case 1: //sgpr_base
10898                 return true;
10899               case 2: //offset
10900                 return true;
10901               default:
10902                 fatal("op idx %i out of bounds\n", opIdx);
10903                 return false;
10904             }
10905         } // isSrcOperand
10906
10907         bool
10908         isDstOperand(int opIdx) override
10909         {
10910             switch (opIdx) {
10911               case 0: //sgpr_data
10912                 return false;
10913               case 1: //sgpr_base
10914                 return false;
10915               case 2: //offset
10916                 return false;
10917               default:
10918                 fatal("op idx %i out of bounds\n", opIdx);
10919                 return false;
10920             }
10921         } // isDstOperand
10922
10923         void execute(GPUDynInstPtr) override;
10924         void initiateAcc(GPUDynInstPtr) override;
10925         void completeAcc(GPUDynInstPtr) override;
10926     }; // Inst_SMEM__S_BUFFER_STORE_DWORD
10927
10928     class Inst_SMEM__S_BUFFER_STORE_DWORDX2 : public Inst_SMEM
10929     {
10930       public:
10931         Inst_SMEM__S_BUFFER_STORE_DWORDX2(InFmt_SMEM*);
10932         ~Inst_SMEM__S_BUFFER_STORE_DWORDX2();
10933
10934         int
10935         getNumOperands() override
10936         {
10937             return numDstRegOperands() + numSrcRegOperands();
10938         } // getNumOperands
10939
10940         int numDstRegOperands() override { return 0; }
10941         int numSrcRegOperands() override { return 3; }
10942
10943         int
10944         getOperandSize(int opIdx) override
10945         {
10946             switch (opIdx) {
10947               case 0: //sgpr_data
10948                 return 8;
10949               case 1: //sgpr_base
10950                 return 16;
10951               case 2: //offset
10952                 return 4;
10953               default:
10954                 fatal("op idx %i out of bounds\n", opIdx);
10955                 return -1;
10956             }
10957         } // getOperandSize
10958
10959         bool
10960         isSrcOperand(int opIdx) override
10961         {
10962             switch (opIdx) {
10963               case 0: //sgpr_data
10964                 return true;
10965               case 1: //sgpr_base
10966                 return true;
10967               case 2: //offset
10968                 return true;
10969               default:
10970                 fatal("op idx %i out of bounds\n", opIdx);
10971                 return false;
10972             }
10973         } // isSrcOperand
10974
10975         bool
10976         isDstOperand(int opIdx) override
10977         {
10978             switch (opIdx) {
10979               case 0: //sgpr_data
10980                 return false;
10981               case 1: //sgpr_base
10982                 return false;
10983               case 2: //offset
10984                 return false;
10985               default:
10986                 fatal("op idx %i out of bounds\n", opIdx);
10987                 return false;
10988             }
10989         } // isDstOperand
10990
10991         void execute(GPUDynInstPtr) override;
10992         void initiateAcc(GPUDynInstPtr) override;
10993         void completeAcc(GPUDynInstPtr) override;
10994     }; // Inst_SMEM__S_BUFFER_STORE_DWORDX2
10995
10996     class Inst_SMEM__S_BUFFER_STORE_DWORDX4 : public Inst_SMEM
10997     {
10998       public:
10999         Inst_SMEM__S_BUFFER_STORE_DWORDX4(InFmt_SMEM*);
11000         ~Inst_SMEM__S_BUFFER_STORE_DWORDX4();
11001
11002         int
11003         getNumOperands() override
11004         {
11005             return numDstRegOperands() + numSrcRegOperands();
11006         } // getNumOperands
11007
11008         int numDstRegOperands() override { return 0; }
11009         int numSrcRegOperands() override { return 3; }
11010
11011         int
11012         getOperandSize(int opIdx) override
11013         {
11014             switch (opIdx) {
11015               case 0: //sgpr_data
11016                 return 16;
11017               case 1: //sgpr_base
11018                 return 16;
11019               case 2: //offset
11020                 return 4;
11021               default:
11022                 fatal("op idx %i out of bounds\n", opIdx);
11023                 return -1;
11024             }
11025         } // getOperandSize
11026
11027         bool
11028         isSrcOperand(int opIdx) override
11029         {
11030             switch (opIdx) {
11031               case 0: //sgpr_data
11032                 return true;
11033               case 1: //sgpr_base
11034                 return true;
11035               case 2: //offset
11036                 return true;
11037               default:
11038                 fatal("op idx %i out of bounds\n", opIdx);
11039                 return false;
11040             }
11041         } // isSrcOperand
11042
11043         bool
11044         isDstOperand(int opIdx) override
11045         {
11046             switch (opIdx) {
11047               case 0: //sgpr_data
11048                 return false;
11049               case 1: //sgpr_base
11050                 return false;
11051               case 2: //offset
11052                 return false;
11053               default:
11054                 fatal("op idx %i out of bounds\n", opIdx);
11055                 return false;
11056             }
11057         } // isDstOperand
11058
11059         void execute(GPUDynInstPtr) override;
11060         void initiateAcc(GPUDynInstPtr) override;
11061         void completeAcc(GPUDynInstPtr) override;
11062     }; // Inst_SMEM__S_BUFFER_STORE_DWORDX4
11063
11064     class Inst_SMEM__S_DCACHE_INV : public Inst_SMEM
11065     {
11066       public:
11067         Inst_SMEM__S_DCACHE_INV(InFmt_SMEM*);
11068         ~Inst_SMEM__S_DCACHE_INV();
11069
11070         int
11071         getNumOperands() override
11072         {
11073             return numDstRegOperands() + numSrcRegOperands();
11074         } // getNumOperands
11075
11076         int numDstRegOperands() override { return 0; }
11077         int numSrcRegOperands() override { return 0; }
11078
11079         int
11080         getOperandSize(int opIdx) override
11081         {
11082             switch (opIdx) {
11083               default:
11084                 fatal("op idx %i out of bounds\n", opIdx);
11085                 return -1;
11086             }
11087         } // getOperandSize
11088
11089         bool
11090         isSrcOperand(int opIdx) override
11091         {
11092             switch (opIdx) {
11093               default:
11094                 fatal("op idx %i out of bounds\n", opIdx);
11095                 return false;
11096             }
11097         } // isSrcOperand
11098
11099         bool
11100         isDstOperand(int opIdx) override
11101         {
11102             switch (opIdx) {
11103               default:
11104                 fatal("op idx %i out of bounds\n", opIdx);
11105                 return false;
11106             }
11107         } // isDstOperand
11108
11109         void execute(GPUDynInstPtr) override;
11110     }; // Inst_SMEM__S_DCACHE_INV
11111
11112     class Inst_SMEM__S_DCACHE_WB : public Inst_SMEM
11113     {
11114       public:
11115         Inst_SMEM__S_DCACHE_WB(InFmt_SMEM*);
11116         ~Inst_SMEM__S_DCACHE_WB();
11117
11118         int
11119         getNumOperands() override
11120         {
11121             return numDstRegOperands() + numSrcRegOperands();
11122         } // getNumOperands
11123
11124         int numDstRegOperands() override { return 0; }
11125         int numSrcRegOperands() override { return 0; }
11126
11127         int
11128         getOperandSize(int opIdx) override
11129         {
11130             switch (opIdx) {
11131               default:
11132                 fatal("op idx %i out of bounds\n", opIdx);
11133                 return -1;
11134             }
11135         } // getOperandSize
11136
11137         bool
11138         isSrcOperand(int opIdx) override
11139         {
11140             switch (opIdx) {
11141               default:
11142                 fatal("op idx %i out of bounds\n", opIdx);
11143                 return false;
11144             }
11145         } // isSrcOperand
11146
11147         bool
11148         isDstOperand(int opIdx) override
11149         {
11150             switch (opIdx) {
11151               default:
11152                 fatal("op idx %i out of bounds\n", opIdx);
11153                 return false;
11154             }
11155         } // isDstOperand
11156
11157         void execute(GPUDynInstPtr) override;
11158     }; // Inst_SMEM__S_DCACHE_WB
11159
11160     class Inst_SMEM__S_DCACHE_INV_VOL : public Inst_SMEM
11161     {
11162       public:
11163         Inst_SMEM__S_DCACHE_INV_VOL(InFmt_SMEM*);
11164         ~Inst_SMEM__S_DCACHE_INV_VOL();
11165
11166         int
11167         getNumOperands() override
11168         {
11169             return numDstRegOperands() + numSrcRegOperands();
11170         } // getNumOperands
11171
11172         int numDstRegOperands() override { return 0; }
11173         int numSrcRegOperands() override { return 0; }
11174
11175         int
11176         getOperandSize(int opIdx) override
11177         {
11178             switch (opIdx) {
11179               default:
11180                 fatal("op idx %i out of bounds\n", opIdx);
11181                 return -1;
11182             }
11183         } // getOperandSize
11184
11185         bool
11186         isSrcOperand(int opIdx) override
11187         {
11188             switch (opIdx) {
11189               default:
11190                 fatal("op idx %i out of bounds\n", opIdx);
11191                 return false;
11192             }
11193         } // isSrcOperand
11194
11195         bool
11196         isDstOperand(int opIdx) override
11197         {
11198             switch (opIdx) {
11199               default:
11200                 fatal("op idx %i out of bounds\n", opIdx);
11201                 return false;
11202             }
11203         } // isDstOperand
11204
11205         void execute(GPUDynInstPtr) override;
11206     }; // Inst_SMEM__S_DCACHE_INV_VOL
11207
11208     class Inst_SMEM__S_DCACHE_WB_VOL : public Inst_SMEM
11209     {
11210       public:
11211         Inst_SMEM__S_DCACHE_WB_VOL(InFmt_SMEM*);
11212         ~Inst_SMEM__S_DCACHE_WB_VOL();
11213
11214         int
11215         getNumOperands() override
11216         {
11217             return numDstRegOperands() + numSrcRegOperands();
11218         } // getNumOperands
11219
11220         int numDstRegOperands() override { return 0; }
11221         int numSrcRegOperands() override { return 0; }
11222
11223         int
11224         getOperandSize(int opIdx) override
11225         {
11226             switch (opIdx) {
11227               default:
11228                 fatal("op idx %i out of bounds\n", opIdx);
11229                 return -1;
11230             }
11231         } // getOperandSize
11232
11233         bool
11234         isSrcOperand(int opIdx) override
11235         {
11236             switch (opIdx) {
11237               default:
11238                 fatal("op idx %i out of bounds\n", opIdx);
11239                 return false;
11240             }
11241         } // isSrcOperand
11242
11243         bool
11244         isDstOperand(int opIdx) override
11245         {
11246             switch (opIdx) {
11247               default:
11248                 fatal("op idx %i out of bounds\n", opIdx);
11249                 return false;
11250             }
11251         } // isDstOperand
11252
11253         void execute(GPUDynInstPtr) override;
11254     }; // Inst_SMEM__S_DCACHE_WB_VOL
11255
11256     class Inst_SMEM__S_MEMTIME : public Inst_SMEM
11257     {
11258       public:
11259         Inst_SMEM__S_MEMTIME(InFmt_SMEM*);
11260         ~Inst_SMEM__S_MEMTIME();
11261
11262         int
11263         getNumOperands() override
11264         {
11265             return numDstRegOperands() + numSrcRegOperands();
11266         } // getNumOperands
11267
11268         int numDstRegOperands() override { return 1; }
11269         int numSrcRegOperands() override { return 0; }
11270
11271         int
11272         getOperandSize(int opIdx) override
11273         {
11274             switch (opIdx) {
11275               case 0: //sgpr_dst
11276                 return 8;
11277               default:
11278                 fatal("op idx %i out of bounds\n", opIdx);
11279                 return -1;
11280             }
11281         } // getOperandSize
11282
11283         bool
11284         isSrcOperand(int opIdx) override
11285         {
11286             switch (opIdx) {
11287               case 0: //sgpr_dst
11288                 return false;
11289               default:
11290                 fatal("op idx %i out of bounds\n", opIdx);
11291                 return false;
11292             }
11293         } // isSrcOperand
11294
11295         bool
11296         isDstOperand(int opIdx) override
11297         {
11298             switch (opIdx) {
11299               case 0: //sgpr_dst
11300                 return true;
11301               default:
11302                 fatal("op idx %i out of bounds\n", opIdx);
11303                 return false;
11304             }
11305         } // isDstOperand
11306
11307         void execute(GPUDynInstPtr) override;
11308     }; // Inst_SMEM__S_MEMTIME
11309
11310     class Inst_SMEM__S_MEMREALTIME : public Inst_SMEM
11311     {
11312       public:
11313         Inst_SMEM__S_MEMREALTIME(InFmt_SMEM*);
11314         ~Inst_SMEM__S_MEMREALTIME();
11315
11316         int
11317         getNumOperands() override
11318         {
11319             return numDstRegOperands() + numSrcRegOperands();
11320         } // getNumOperands
11321
11322         int numDstRegOperands() override { return 1; }
11323         int numSrcRegOperands() override { return 0; }
11324
11325         int
11326         getOperandSize(int opIdx) override
11327         {
11328             switch (opIdx) {
11329               case 0: //sgpr_dst
11330                 return 8;
11331               default:
11332                 fatal("op idx %i out of bounds\n", opIdx);
11333                 return -1;
11334             }
11335         } // getOperandSize
11336
11337         bool
11338         isSrcOperand(int opIdx) override
11339         {
11340             switch (opIdx) {
11341               case 0: //sgpr_dst
11342                 return false;
11343               default:
11344                 fatal("op idx %i out of bounds\n", opIdx);
11345                 return false;
11346             }
11347         } // isSrcOperand
11348
11349         bool
11350         isDstOperand(int opIdx) override
11351         {
11352             switch (opIdx) {
11353               case 0: //sgpr_dst
11354                 return true;
11355               default:
11356                 fatal("op idx %i out of bounds\n", opIdx);
11357                 return false;
11358             }
11359         } // isDstOperand
11360
11361         void execute(GPUDynInstPtr) override;
11362     }; // Inst_SMEM__S_MEMREALTIME
11363
11364     class Inst_SMEM__S_ATC_PROBE : public Inst_SMEM
11365     {
11366       public:
11367         Inst_SMEM__S_ATC_PROBE(InFmt_SMEM*);
11368         ~Inst_SMEM__S_ATC_PROBE();
11369
11370         int
11371         getNumOperands() override
11372         {
11373             return numDstRegOperands() + numSrcRegOperands();
11374         } // getNumOperands
11375
11376         int numDstRegOperands() override { return 0; }
11377         int numSrcRegOperands() override { return 3; }
11378
11379         int
11380         getOperandSize(int opIdx) override
11381         {
11382             switch (opIdx) {
11383               case 0: //perm_rwx
11384                 return 32;
11385               case 1: //sgpr_base
11386                 return 8;
11387               case 2: //offset
11388                 return 4;
11389               default:
11390                 fatal("op idx %i out of bounds\n", opIdx);
11391                 return -1;
11392             }
11393         } // getOperandSize
11394
11395         bool
11396         isSrcOperand(int opIdx) override
11397         {
11398             switch (opIdx) {
11399               case 0: //perm_rwx
11400                 return true;
11401               case 1: //sgpr_base
11402                 return true;
11403               case 2: //offset
11404                 return true;
11405               default:
11406                 fatal("op idx %i out of bounds\n", opIdx);
11407                 return false;
11408             }
11409         } // isSrcOperand
11410
11411         bool
11412         isDstOperand(int opIdx) override
11413         {
11414             switch (opIdx) {
11415               case 0: //perm_rwx
11416                 return false;
11417               case 1: //sgpr_base
11418                 return false;
11419               case 2: //offset
11420                 return false;
11421               default:
11422                 fatal("op idx %i out of bounds\n", opIdx);
11423                 return false;
11424             }
11425         } // isDstOperand
11426
11427         void execute(GPUDynInstPtr) override;
11428     }; // Inst_SMEM__S_ATC_PROBE
11429
11430     class Inst_SMEM__S_ATC_PROBE_BUFFER : public Inst_SMEM
11431     {
11432       public:
11433         Inst_SMEM__S_ATC_PROBE_BUFFER(InFmt_SMEM*);
11434         ~Inst_SMEM__S_ATC_PROBE_BUFFER();
11435
11436         int
11437         getNumOperands() override
11438         {
11439             return numDstRegOperands() + numSrcRegOperands();
11440         } // getNumOperands
11441
11442         int numDstRegOperands() override { return 0; }
11443         int numSrcRegOperands() override { return 3; }
11444
11445         int
11446         getOperandSize(int opIdx) override
11447         {
11448             switch (opIdx) {
11449               case 0: //perm_rwx
11450                 return 32;
11451               case 1: //sgpr_base
11452                 return 16;
11453               case 2: //offset
11454                 return 4;
11455               default:
11456                 fatal("op idx %i out of bounds\n", opIdx);
11457                 return -1;
11458             }
11459         } // getOperandSize
11460
11461         bool
11462         isSrcOperand(int opIdx) override
11463         {
11464             switch (opIdx) {
11465               case 0: //perm_rwx
11466                 return true;
11467               case 1: //sgpr_base
11468                 return true;
11469               case 2: //offset
11470                 return true;
11471               default:
11472                 fatal("op idx %i out of bounds\n", opIdx);
11473                 return false;
11474             }
11475         } // isSrcOperand
11476
11477         bool
11478         isDstOperand(int opIdx) override
11479         {
11480             switch (opIdx) {
11481               case 0: //perm_rwx
11482                 return false;
11483               case 1: //sgpr_base
11484                 return false;
11485               case 2: //offset
11486                 return false;
11487               default:
11488                 fatal("op idx %i out of bounds\n", opIdx);
11489                 return false;
11490             }
11491         } // isDstOperand
11492
11493         void execute(GPUDynInstPtr) override;
11494     }; // Inst_SMEM__S_ATC_PROBE_BUFFER
11495
11496     class Inst_VOP2__V_CNDMASK_B32 : public Inst_VOP2
11497     {
11498       public:
11499         Inst_VOP2__V_CNDMASK_B32(InFmt_VOP2*);
11500         ~Inst_VOP2__V_CNDMASK_B32();
11501
11502         int
11503         getNumOperands() override
11504         {
11505             return numDstRegOperands() + numSrcRegOperands();
11506         } // getNumOperands
11507
11508         int numDstRegOperands() override { return 1; }
11509         int numSrcRegOperands() override { return 3; }
11510
11511         int
11512         getOperandSize(int opIdx) override
11513         {
11514             switch (opIdx) {
11515               case 0: //src_0
11516                 return 4;
11517               case 1: //src_1
11518                 return 4;
11519               case 2: //vcc
11520                 return 8;
11521               case 3: //vdst
11522                 return 4;
11523               default:
11524                 fatal("op idx %i out of bounds\n", opIdx);
11525                 return -1;
11526             }
11527         } // getOperandSize
11528
11529         bool
11530         isSrcOperand(int opIdx) override
11531         {
11532             switch (opIdx) {
11533               case 0: //src_0
11534                 return true;
11535               case 1: //src_1
11536                 return true;
11537               case 2: //vcc
11538                 return true;
11539               case 3: //vdst
11540                 return false;
11541               default:
11542                 fatal("op idx %i out of bounds\n", opIdx);
11543                 return false;
11544             }
11545         } // isSrcOperand
11546
11547         bool
11548         isDstOperand(int opIdx) override
11549         {
11550             switch (opIdx) {
11551               case 0: //src_0
11552                 return false;
11553               case 1: //src_1
11554                 return false;
11555               case 2: //vcc
11556                 return false;
11557               case 3: //vdst
11558                 return true;
11559               default:
11560                 fatal("op idx %i out of bounds\n", opIdx);
11561                 return false;
11562             }
11563         } // isDstOperand
11564
11565         void execute(GPUDynInstPtr) override;
11566     }; // Inst_VOP2__V_CNDMASK_B32
11567
11568     class Inst_VOP2__V_ADD_F32 : public Inst_VOP2
11569     {
11570       public:
11571         Inst_VOP2__V_ADD_F32(InFmt_VOP2*);
11572         ~Inst_VOP2__V_ADD_F32();
11573
11574         int
11575         getNumOperands() override
11576         {
11577             return numDstRegOperands() + numSrcRegOperands();
11578         } // getNumOperands
11579
11580         int numDstRegOperands() override { return 1; }
11581         int numSrcRegOperands() override { return 2; }
11582
11583         int
11584         getOperandSize(int opIdx) override
11585         {
11586             switch (opIdx) {
11587               case 0: //src_0
11588                 return 4;
11589               case 1: //src_1
11590                 return 4;
11591               case 2: //vdst
11592                 return 4;
11593               default:
11594                 fatal("op idx %i out of bounds\n", opIdx);
11595                 return -1;
11596             }
11597         } // getOperandSize
11598
11599         bool
11600         isSrcOperand(int opIdx) override
11601         {
11602             switch (opIdx) {
11603               case 0: //src_0
11604                 return true;
11605               case 1: //src_1
11606                 return true;
11607               case 2: //vdst
11608                 return false;
11609               default:
11610                 fatal("op idx %i out of bounds\n", opIdx);
11611                 return false;
11612             }
11613         } // isSrcOperand
11614
11615         bool
11616         isDstOperand(int opIdx) override
11617         {
11618             switch (opIdx) {
11619               case 0: //src_0
11620                 return false;
11621               case 1: //src_1
11622                 return false;
11623               case 2: //vdst
11624                 return true;
11625               default:
11626                 fatal("op idx %i out of bounds\n", opIdx);
11627                 return false;
11628             }
11629         } // isDstOperand
11630
11631         void execute(GPUDynInstPtr) override;
11632     }; // Inst_VOP2__V_ADD_F32
11633
11634     class Inst_VOP2__V_SUB_F32 : public Inst_VOP2
11635     {
11636       public:
11637         Inst_VOP2__V_SUB_F32(InFmt_VOP2*);
11638         ~Inst_VOP2__V_SUB_F32();
11639
11640         int
11641         getNumOperands() override
11642         {
11643             return numDstRegOperands() + numSrcRegOperands();
11644         } // getNumOperands
11645
11646         int numDstRegOperands() override { return 1; }
11647         int numSrcRegOperands() override { return 2; }
11648
11649         int
11650         getOperandSize(int opIdx) override
11651         {
11652             switch (opIdx) {
11653               case 0: //src_0
11654                 return 4;
11655               case 1: //src_1
11656                 return 4;
11657               case 2: //vdst
11658                 return 4;
11659               default:
11660                 fatal("op idx %i out of bounds\n", opIdx);
11661                 return -1;
11662             }
11663         } // getOperandSize
11664
11665         bool
11666         isSrcOperand(int opIdx) override
11667         {
11668             switch (opIdx) {
11669               case 0: //src_0
11670                 return true;
11671               case 1: //src_1
11672                 return true;
11673               case 2: //vdst
11674                 return false;
11675               default:
11676                 fatal("op idx %i out of bounds\n", opIdx);
11677                 return false;
11678             }
11679         } // isSrcOperand
11680
11681         bool
11682         isDstOperand(int opIdx) override
11683         {
11684             switch (opIdx) {
11685               case 0: //src_0
11686                 return false;
11687               case 1: //src_1
11688                 return false;
11689               case 2: //vdst
11690                 return true;
11691               default:
11692                 fatal("op idx %i out of bounds\n", opIdx);
11693                 return false;
11694             }
11695         } // isDstOperand
11696
11697         void execute(GPUDynInstPtr) override;
11698     }; // Inst_VOP2__V_SUB_F32
11699
11700     class Inst_VOP2__V_SUBREV_F32 : public Inst_VOP2
11701     {
11702       public:
11703         Inst_VOP2__V_SUBREV_F32(InFmt_VOP2*);
11704         ~Inst_VOP2__V_SUBREV_F32();
11705
11706         int
11707         getNumOperands() override
11708         {
11709             return numDstRegOperands() + numSrcRegOperands();
11710         } // getNumOperands
11711
11712         int numDstRegOperands() override { return 1; }
11713         int numSrcRegOperands() override { return 2; }
11714
11715         int
11716         getOperandSize(int opIdx) override
11717         {
11718             switch (opIdx) {
11719               case 0: //src_0
11720                 return 4;
11721               case 1: //src_1
11722                 return 4;
11723               case 2: //vdst
11724                 return 4;
11725               default:
11726                 fatal("op idx %i out of bounds\n", opIdx);
11727                 return -1;
11728             }
11729         } // getOperandSize
11730
11731         bool
11732         isSrcOperand(int opIdx) override
11733         {
11734             switch (opIdx) {
11735               case 0: //src_0
11736                 return true;
11737               case 1: //src_1
11738                 return true;
11739               case 2: //vdst
11740                 return false;
11741               default:
11742                 fatal("op idx %i out of bounds\n", opIdx);
11743                 return false;
11744             }
11745         } // isSrcOperand
11746
11747         bool
11748         isDstOperand(int opIdx) override
11749         {
11750             switch (opIdx) {
11751               case 0: //src_0
11752                 return false;
11753               case 1: //src_1
11754                 return false;
11755               case 2: //vdst
11756                 return true;
11757               default:
11758                 fatal("op idx %i out of bounds\n", opIdx);
11759                 return false;
11760             }
11761         } // isDstOperand
11762
11763         void execute(GPUDynInstPtr) override;
11764     }; // Inst_VOP2__V_SUBREV_F32
11765
11766     class Inst_VOP2__V_MUL_LEGACY_F32 : public Inst_VOP2
11767     {
11768       public:
11769         Inst_VOP2__V_MUL_LEGACY_F32(InFmt_VOP2*);
11770         ~Inst_VOP2__V_MUL_LEGACY_F32();
11771
11772         int
11773         getNumOperands() override
11774         {
11775             return numDstRegOperands() + numSrcRegOperands();
11776         } // getNumOperands
11777
11778         int numDstRegOperands() override { return 1; }
11779         int numSrcRegOperands() override { return 2; }
11780
11781         int
11782         getOperandSize(int opIdx) override
11783         {
11784             switch (opIdx) {
11785               case 0: //src_0
11786                 return 4;
11787               case 1: //src_1
11788                 return 4;
11789               case 2: //vdst
11790                 return 4;
11791               default:
11792                 fatal("op idx %i out of bounds\n", opIdx);
11793                 return -1;
11794             }
11795         } // getOperandSize
11796
11797         bool
11798         isSrcOperand(int opIdx) override
11799         {
11800             switch (opIdx) {
11801               case 0: //src_0
11802                 return true;
11803               case 1: //src_1
11804                 return true;
11805               case 2: //vdst
11806                 return false;
11807               default:
11808                 fatal("op idx %i out of bounds\n", opIdx);
11809                 return false;
11810             }
11811         } // isSrcOperand
11812
11813         bool
11814         isDstOperand(int opIdx) override
11815         {
11816             switch (opIdx) {
11817               case 0: //src_0
11818                 return false;
11819               case 1: //src_1
11820                 return false;
11821               case 2: //vdst
11822                 return true;
11823               default:
11824                 fatal("op idx %i out of bounds\n", opIdx);
11825                 return false;
11826             }
11827         } // isDstOperand
11828
11829         void execute(GPUDynInstPtr) override;
11830     }; // Inst_VOP2__V_MUL_LEGACY_F32
11831
11832     class Inst_VOP2__V_MUL_F32 : public Inst_VOP2
11833     {
11834       public:
11835         Inst_VOP2__V_MUL_F32(InFmt_VOP2*);
11836         ~Inst_VOP2__V_MUL_F32();
11837
11838         int
11839         getNumOperands() override
11840         {
11841             return numDstRegOperands() + numSrcRegOperands();
11842         } // getNumOperands
11843
11844         int numDstRegOperands() override { return 1; }
11845         int numSrcRegOperands() override { return 2; }
11846
11847         int
11848         getOperandSize(int opIdx) override
11849         {
11850             switch (opIdx) {
11851               case 0: //src_0
11852                 return 4;
11853               case 1: //src_1
11854                 return 4;
11855               case 2: //vdst
11856                 return 4;
11857               default:
11858                 fatal("op idx %i out of bounds\n", opIdx);
11859                 return -1;
11860             }
11861         } // getOperandSize
11862
11863         bool
11864         isSrcOperand(int opIdx) override
11865         {
11866             switch (opIdx) {
11867               case 0: //src_0
11868                 return true;
11869               case 1: //src_1
11870                 return true;
11871               case 2: //vdst
11872                 return false;
11873               default:
11874                 fatal("op idx %i out of bounds\n", opIdx);
11875                 return false;
11876             }
11877         } // isSrcOperand
11878
11879         bool
11880         isDstOperand(int opIdx) override
11881         {
11882             switch (opIdx) {
11883               case 0: //src_0
11884                 return false;
11885               case 1: //src_1
11886                 return false;
11887               case 2: //vdst
11888                 return true;
11889               default:
11890                 fatal("op idx %i out of bounds\n", opIdx);
11891                 return false;
11892             }
11893         } // isDstOperand
11894
11895         void execute(GPUDynInstPtr) override;
11896     }; // Inst_VOP2__V_MUL_F32
11897
11898     class Inst_VOP2__V_MUL_I32_I24 : public Inst_VOP2
11899     {
11900       public:
11901         Inst_VOP2__V_MUL_I32_I24(InFmt_VOP2*);
11902         ~Inst_VOP2__V_MUL_I32_I24();
11903
11904         int
11905         getNumOperands() override
11906         {
11907             return numDstRegOperands() + numSrcRegOperands();
11908         } // getNumOperands
11909
11910         int numDstRegOperands() override { return 1; }
11911         int numSrcRegOperands() override { return 2; }
11912
11913         int
11914         getOperandSize(int opIdx) override
11915         {
11916             switch (opIdx) {
11917               case 0: //src_0
11918                 return 4;
11919               case 1: //src_1
11920                 return 4;
11921               case 2: //vdst
11922                 return 4;
11923               default:
11924                 fatal("op idx %i out of bounds\n", opIdx);
11925                 return -1;
11926             }
11927         } // getOperandSize
11928
11929         bool
11930         isSrcOperand(int opIdx) override
11931         {
11932             switch (opIdx) {
11933               case 0: //src_0
11934                 return true;
11935               case 1: //src_1
11936                 return true;
11937               case 2: //vdst
11938                 return false;
11939               default:
11940                 fatal("op idx %i out of bounds\n", opIdx);
11941                 return false;
11942             }
11943         } // isSrcOperand
11944
11945         bool
11946         isDstOperand(int opIdx) override
11947         {
11948             switch (opIdx) {
11949               case 0: //src_0
11950                 return false;
11951               case 1: //src_1
11952                 return false;
11953               case 2: //vdst
11954                 return true;
11955               default:
11956                 fatal("op idx %i out of bounds\n", opIdx);
11957                 return false;
11958             }
11959         } // isDstOperand
11960
11961         void execute(GPUDynInstPtr) override;
11962     }; // Inst_VOP2__V_MUL_I32_I24
11963
11964     class Inst_VOP2__V_MUL_HI_I32_I24 : public Inst_VOP2
11965     {
11966       public:
11967         Inst_VOP2__V_MUL_HI_I32_I24(InFmt_VOP2*);
11968         ~Inst_VOP2__V_MUL_HI_I32_I24();
11969
11970         int
11971         getNumOperands() override
11972         {
11973             return numDstRegOperands() + numSrcRegOperands();
11974         } // getNumOperands
11975
11976         int numDstRegOperands() override { return 1; }
11977         int numSrcRegOperands() override { return 2; }
11978
11979         int
11980         getOperandSize(int opIdx) override
11981         {
11982             switch (opIdx) {
11983               case 0: //src_0
11984                 return 4;
11985               case 1: //src_1
11986                 return 4;
11987               case 2: //vdst
11988                 return 4;
11989               default:
11990                 fatal("op idx %i out of bounds\n", opIdx);
11991                 return -1;
11992             }
11993         } // getOperandSize
11994
11995         bool
11996         isSrcOperand(int opIdx) override
11997         {
11998             switch (opIdx) {
11999               case 0: //src_0
12000                 return true;
12001               case 1: //src_1
12002                 return true;
12003               case 2: //vdst
12004                 return false;
12005               default:
12006                 fatal("op idx %i out of bounds\n", opIdx);
12007                 return false;
12008             }
12009         } // isSrcOperand
12010
12011         bool
12012         isDstOperand(int opIdx) override
12013         {
12014             switch (opIdx) {
12015               case 0: //src_0
12016                 return false;
12017               case 1: //src_1
12018                 return false;
12019               case 2: //vdst
12020                 return true;
12021               default:
12022                 fatal("op idx %i out of bounds\n", opIdx);
12023                 return false;
12024             }
12025         } // isDstOperand
12026
12027         void execute(GPUDynInstPtr) override;
12028     }; // Inst_VOP2__V_MUL_HI_I32_I24
12029
12030     class Inst_VOP2__V_MUL_U32_U24 : public Inst_VOP2
12031     {
12032       public:
12033         Inst_VOP2__V_MUL_U32_U24(InFmt_VOP2*);
12034         ~Inst_VOP2__V_MUL_U32_U24();
12035
12036         int
12037         getNumOperands() override
12038         {
12039             return numDstRegOperands() + numSrcRegOperands();
12040         } // getNumOperands
12041
12042         int numDstRegOperands() override { return 1; }
12043         int numSrcRegOperands() override { return 2; }
12044
12045         int
12046         getOperandSize(int opIdx) override
12047         {
12048             switch (opIdx) {
12049               case 0: //src_0
12050                 return 4;
12051               case 1: //src_1
12052                 return 4;
12053               case 2: //vdst
12054                 return 4;
12055               default:
12056                 fatal("op idx %i out of bounds\n", opIdx);
12057                 return -1;
12058             }
12059         } // getOperandSize
12060
12061         bool
12062         isSrcOperand(int opIdx) override
12063         {
12064             switch (opIdx) {
12065               case 0: //src_0
12066                 return true;
12067               case 1: //src_1
12068                 return true;
12069               case 2: //vdst
12070                 return false;
12071               default:
12072                 fatal("op idx %i out of bounds\n", opIdx);
12073                 return false;
12074             }
12075         } // isSrcOperand
12076
12077         bool
12078         isDstOperand(int opIdx) override
12079         {
12080             switch (opIdx) {
12081               case 0: //src_0
12082                 return false;
12083               case 1: //src_1
12084                 return false;
12085               case 2: //vdst
12086                 return true;
12087               default:
12088                 fatal("op idx %i out of bounds\n", opIdx);
12089                 return false;
12090             }
12091         } // isDstOperand
12092
12093         void execute(GPUDynInstPtr) override;
12094     }; // Inst_VOP2__V_MUL_U32_U24
12095
12096     class Inst_VOP2__V_MUL_HI_U32_U24 : public Inst_VOP2
12097     {
12098       public:
12099         Inst_VOP2__V_MUL_HI_U32_U24(InFmt_VOP2*);
12100         ~Inst_VOP2__V_MUL_HI_U32_U24();
12101
12102         int
12103         getNumOperands() override
12104         {
12105             return numDstRegOperands() + numSrcRegOperands();
12106         } // getNumOperands
12107
12108         int numDstRegOperands() override { return 1; }
12109         int numSrcRegOperands() override { return 2; }
12110
12111         int
12112         getOperandSize(int opIdx) override
12113         {
12114             switch (opIdx) {
12115               case 0: //src_0
12116                 return 4;
12117               case 1: //src_1
12118                 return 4;
12119               case 2: //vdst
12120                 return 4;
12121               default:
12122                 fatal("op idx %i out of bounds\n", opIdx);
12123                 return -1;
12124             }
12125         } // getOperandSize
12126
12127         bool
12128         isSrcOperand(int opIdx) override
12129         {
12130             switch (opIdx) {
12131               case 0: //src_0
12132                 return true;
12133               case 1: //src_1
12134                 return true;
12135               case 2: //vdst
12136                 return false;
12137               default:
12138                 fatal("op idx %i out of bounds\n", opIdx);
12139                 return false;
12140             }
12141         } // isSrcOperand
12142
12143         bool
12144         isDstOperand(int opIdx) override
12145         {
12146             switch (opIdx) {
12147               case 0: //src_0
12148                 return false;
12149               case 1: //src_1
12150                 return false;
12151               case 2: //vdst
12152                 return true;
12153               default:
12154                 fatal("op idx %i out of bounds\n", opIdx);
12155                 return false;
12156             }
12157         } // isDstOperand
12158
12159         void execute(GPUDynInstPtr) override;
12160     }; // Inst_VOP2__V_MUL_HI_U32_U24
12161
12162     class Inst_VOP2__V_MIN_F32 : public Inst_VOP2
12163     {
12164       public:
12165         Inst_VOP2__V_MIN_F32(InFmt_VOP2*);
12166         ~Inst_VOP2__V_MIN_F32();
12167
12168         int
12169         getNumOperands() override
12170         {
12171             return numDstRegOperands() + numSrcRegOperands();
12172         } // getNumOperands
12173
12174         int numDstRegOperands() override { return 1; }
12175         int numSrcRegOperands() override { return 2; }
12176
12177         int
12178         getOperandSize(int opIdx) override
12179         {
12180             switch (opIdx) {
12181               case 0: //src_0
12182                 return 4;
12183               case 1: //src_1
12184                 return 4;
12185               case 2: //vdst
12186                 return 4;
12187               default:
12188                 fatal("op idx %i out of bounds\n", opIdx);
12189                 return -1;
12190             }
12191         } // getOperandSize
12192
12193         bool
12194         isSrcOperand(int opIdx) override
12195         {
12196             switch (opIdx) {
12197               case 0: //src_0
12198                 return true;
12199               case 1: //src_1
12200                 return true;
12201               case 2: //vdst
12202                 return false;
12203               default:
12204                 fatal("op idx %i out of bounds\n", opIdx);
12205                 return false;
12206             }
12207         } // isSrcOperand
12208
12209         bool
12210         isDstOperand(int opIdx) override
12211         {
12212             switch (opIdx) {
12213               case 0: //src_0
12214                 return false;
12215               case 1: //src_1
12216                 return false;
12217               case 2: //vdst
12218                 return true;
12219               default:
12220                 fatal("op idx %i out of bounds\n", opIdx);
12221                 return false;
12222             }
12223         } // isDstOperand
12224
12225         void execute(GPUDynInstPtr) override;
12226     }; // Inst_VOP2__V_MIN_F32
12227
12228     class Inst_VOP2__V_MAX_F32 : public Inst_VOP2
12229     {
12230       public:
12231         Inst_VOP2__V_MAX_F32(InFmt_VOP2*);
12232         ~Inst_VOP2__V_MAX_F32();
12233
12234         int
12235         getNumOperands() override
12236         {
12237             return numDstRegOperands() + numSrcRegOperands();
12238         } // getNumOperands
12239
12240         int numDstRegOperands() override { return 1; }
12241         int numSrcRegOperands() override { return 2; }
12242
12243         int
12244         getOperandSize(int opIdx) override
12245         {
12246             switch (opIdx) {
12247               case 0: //src_0
12248                 return 4;
12249               case 1: //src_1
12250                 return 4;
12251               case 2: //vdst
12252                 return 4;
12253               default:
12254                 fatal("op idx %i out of bounds\n", opIdx);
12255                 return -1;
12256             }
12257         } // getOperandSize
12258
12259         bool
12260         isSrcOperand(int opIdx) override
12261         {
12262             switch (opIdx) {
12263               case 0: //src_0
12264                 return true;
12265               case 1: //src_1
12266                 return true;
12267               case 2: //vdst
12268                 return false;
12269               default:
12270                 fatal("op idx %i out of bounds\n", opIdx);
12271                 return false;
12272             }
12273         } // isSrcOperand
12274
12275         bool
12276         isDstOperand(int opIdx) override
12277         {
12278             switch (opIdx) {
12279               case 0: //src_0
12280                 return false;
12281               case 1: //src_1
12282                 return false;
12283               case 2: //vdst
12284                 return true;
12285               default:
12286                 fatal("op idx %i out of bounds\n", opIdx);
12287                 return false;
12288             }
12289         } // isDstOperand
12290
12291         void execute(GPUDynInstPtr) override;
12292     }; // Inst_VOP2__V_MAX_F32
12293
12294     class Inst_VOP2__V_MIN_I32 : public Inst_VOP2
12295     {
12296       public:
12297         Inst_VOP2__V_MIN_I32(InFmt_VOP2*);
12298         ~Inst_VOP2__V_MIN_I32();
12299
12300         int
12301         getNumOperands() override
12302         {
12303             return numDstRegOperands() + numSrcRegOperands();
12304         } // getNumOperands
12305
12306         int numDstRegOperands() override { return 1; }
12307         int numSrcRegOperands() override { return 2; }
12308
12309         int
12310         getOperandSize(int opIdx) override
12311         {
12312             switch (opIdx) {
12313               case 0: //src_0
12314                 return 4;
12315               case 1: //src_1
12316                 return 4;
12317               case 2: //vdst
12318                 return 4;
12319               default:
12320                 fatal("op idx %i out of bounds\n", opIdx);
12321                 return -1;
12322             }
12323         } // getOperandSize
12324
12325         bool
12326         isSrcOperand(int opIdx) override
12327         {
12328             switch (opIdx) {
12329               case 0: //src_0
12330                 return true;
12331               case 1: //src_1
12332                 return true;
12333               case 2: //vdst
12334                 return false;
12335               default:
12336                 fatal("op idx %i out of bounds\n", opIdx);
12337                 return false;
12338             }
12339         } // isSrcOperand
12340
12341         bool
12342         isDstOperand(int opIdx) override
12343         {
12344             switch (opIdx) {
12345               case 0: //src_0
12346                 return false;
12347               case 1: //src_1
12348                 return false;
12349               case 2: //vdst
12350                 return true;
12351               default:
12352                 fatal("op idx %i out of bounds\n", opIdx);
12353                 return false;
12354             }
12355         } // isDstOperand
12356
12357         void execute(GPUDynInstPtr) override;
12358     }; // Inst_VOP2__V_MIN_I32
12359
12360     class Inst_VOP2__V_MAX_I32 : public Inst_VOP2
12361     {
12362       public:
12363         Inst_VOP2__V_MAX_I32(InFmt_VOP2*);
12364         ~Inst_VOP2__V_MAX_I32();
12365
12366         int
12367         getNumOperands() override
12368         {
12369             return numDstRegOperands() + numSrcRegOperands();
12370         } // getNumOperands
12371
12372         int numDstRegOperands() override { return 1; }
12373         int numSrcRegOperands() override { return 2; }
12374
12375         int
12376         getOperandSize(int opIdx) override
12377         {
12378             switch (opIdx) {
12379               case 0: //src_0
12380                 return 4;
12381               case 1: //src_1
12382                 return 4;
12383               case 2: //vdst
12384                 return 4;
12385               default:
12386                 fatal("op idx %i out of bounds\n", opIdx);
12387                 return -1;
12388             }
12389         } // getOperandSize
12390
12391         bool
12392         isSrcOperand(int opIdx) override
12393         {
12394             switch (opIdx) {
12395               case 0: //src_0
12396                 return true;
12397               case 1: //src_1
12398                 return true;
12399               case 2: //vdst
12400                 return false;
12401               default:
12402                 fatal("op idx %i out of bounds\n", opIdx);
12403                 return false;
12404             }
12405         } // isSrcOperand
12406
12407         bool
12408         isDstOperand(int opIdx) override
12409         {
12410             switch (opIdx) {
12411               case 0: //src_0
12412                 return false;
12413               case 1: //src_1
12414                 return false;
12415               case 2: //vdst
12416                 return true;
12417               default:
12418                 fatal("op idx %i out of bounds\n", opIdx);
12419                 return false;
12420             }
12421         } // isDstOperand
12422
12423         void execute(GPUDynInstPtr) override;
12424     }; // Inst_VOP2__V_MAX_I32
12425
12426     class Inst_VOP2__V_MIN_U32 : public Inst_VOP2
12427     {
12428       public:
12429         Inst_VOP2__V_MIN_U32(InFmt_VOP2*);
12430         ~Inst_VOP2__V_MIN_U32();
12431
12432         int
12433         getNumOperands() override
12434         {
12435             return numDstRegOperands() + numSrcRegOperands();
12436         } // getNumOperands
12437
12438         int numDstRegOperands() override { return 1; }
12439         int numSrcRegOperands() override { return 2; }
12440
12441         int
12442         getOperandSize(int opIdx) override
12443         {
12444             switch (opIdx) {
12445               case 0: //src_0
12446                 return 4;
12447               case 1: //src_1
12448                 return 4;
12449               case 2: //vdst
12450                 return 4;
12451               default:
12452                 fatal("op idx %i out of bounds\n", opIdx);
12453                 return -1;
12454             }
12455         } // getOperandSize
12456
12457         bool
12458         isSrcOperand(int opIdx) override
12459         {
12460             switch (opIdx) {
12461               case 0: //src_0
12462                 return true;
12463               case 1: //src_1
12464                 return true;
12465               case 2: //vdst
12466                 return false;
12467               default:
12468                 fatal("op idx %i out of bounds\n", opIdx);
12469                 return false;
12470             }
12471         } // isSrcOperand
12472
12473         bool
12474         isDstOperand(int opIdx) override
12475         {
12476             switch (opIdx) {
12477               case 0: //src_0
12478                 return false;
12479               case 1: //src_1
12480                 return false;
12481               case 2: //vdst
12482                 return true;
12483               default:
12484                 fatal("op idx %i out of bounds\n", opIdx);
12485                 return false;
12486             }
12487         } // isDstOperand
12488
12489         void execute(GPUDynInstPtr) override;
12490     }; // Inst_VOP2__V_MIN_U32
12491
12492     class Inst_VOP2__V_MAX_U32 : public Inst_VOP2
12493     {
12494       public:
12495         Inst_VOP2__V_MAX_U32(InFmt_VOP2*);
12496         ~Inst_VOP2__V_MAX_U32();
12497
12498         int
12499         getNumOperands() override
12500         {
12501             return numDstRegOperands() + numSrcRegOperands();
12502         } // getNumOperands
12503
12504         int numDstRegOperands() override { return 1; }
12505         int numSrcRegOperands() override { return 2; }
12506
12507         int
12508         getOperandSize(int opIdx) override
12509         {
12510             switch (opIdx) {
12511               case 0: //src_0
12512                 return 4;
12513               case 1: //src_1
12514                 return 4;
12515               case 2: //vdst
12516                 return 4;
12517               default:
12518                 fatal("op idx %i out of bounds\n", opIdx);
12519                 return -1;
12520             }
12521         } // getOperandSize
12522
12523         bool
12524         isSrcOperand(int opIdx) override
12525         {
12526             switch (opIdx) {
12527               case 0: //src_0
12528                 return true;
12529               case 1: //src_1
12530                 return true;
12531               case 2: //vdst
12532                 return false;
12533               default:
12534                 fatal("op idx %i out of bounds\n", opIdx);
12535                 return false;
12536             }
12537         } // isSrcOperand
12538
12539         bool
12540         isDstOperand(int opIdx) override
12541         {
12542             switch (opIdx) {
12543               case 0: //src_0
12544                 return false;
12545               case 1: //src_1
12546                 return false;
12547               case 2: //vdst
12548                 return true;
12549               default:
12550                 fatal("op idx %i out of bounds\n", opIdx);
12551                 return false;
12552             }
12553         } // isDstOperand
12554
12555         void execute(GPUDynInstPtr) override;
12556     }; // Inst_VOP2__V_MAX_U32
12557
12558     class Inst_VOP2__V_LSHRREV_B32 : public Inst_VOP2
12559     {
12560       public:
12561         Inst_VOP2__V_LSHRREV_B32(InFmt_VOP2*);
12562         ~Inst_VOP2__V_LSHRREV_B32();
12563
12564         int
12565         getNumOperands() override
12566         {
12567             return numDstRegOperands() + numSrcRegOperands();
12568         } // getNumOperands
12569
12570         int numDstRegOperands() override { return 1; }
12571         int numSrcRegOperands() override { return 2; }
12572
12573         int
12574         getOperandSize(int opIdx) override
12575         {
12576             switch (opIdx) {
12577               case 0: //src_0
12578                 return 4;
12579               case 1: //src_1
12580                 return 4;
12581               case 2: //vdst
12582                 return 4;
12583               default:
12584                 fatal("op idx %i out of bounds\n", opIdx);
12585                 return -1;
12586             }
12587         } // getOperandSize
12588
12589         bool
12590         isSrcOperand(int opIdx) override
12591         {
12592             switch (opIdx) {
12593               case 0: //src_0
12594                 return true;
12595               case 1: //src_1
12596                 return true;
12597               case 2: //vdst
12598                 return false;
12599               default:
12600                 fatal("op idx %i out of bounds\n", opIdx);
12601                 return false;
12602             }
12603         } // isSrcOperand
12604
12605         bool
12606         isDstOperand(int opIdx) override
12607         {
12608             switch (opIdx) {
12609               case 0: //src_0
12610                 return false;
12611               case 1: //src_1
12612                 return false;
12613               case 2: //vdst
12614                 return true;
12615               default:
12616                 fatal("op idx %i out of bounds\n", opIdx);
12617                 return false;
12618             }
12619         } // isDstOperand
12620
12621         void execute(GPUDynInstPtr) override;
12622     }; // Inst_VOP2__V_LSHRREV_B32
12623
12624     class Inst_VOP2__V_ASHRREV_I32 : public Inst_VOP2
12625     {
12626       public:
12627         Inst_VOP2__V_ASHRREV_I32(InFmt_VOP2*);
12628         ~Inst_VOP2__V_ASHRREV_I32();
12629
12630         int
12631         getNumOperands() override
12632         {
12633             return numDstRegOperands() + numSrcRegOperands();
12634         } // getNumOperands
12635
12636         int numDstRegOperands() override { return 1; }
12637         int numSrcRegOperands() override { return 2; }
12638
12639         int
12640         getOperandSize(int opIdx) override
12641         {
12642             switch (opIdx) {
12643               case 0: //src_0
12644                 return 4;
12645               case 1: //src_1
12646                 return 4;
12647               case 2: //vdst
12648                 return 4;
12649               default:
12650                 fatal("op idx %i out of bounds\n", opIdx);
12651                 return -1;
12652             }
12653         } // getOperandSize
12654
12655         bool
12656         isSrcOperand(int opIdx) override
12657         {
12658             switch (opIdx) {
12659               case 0: //src_0
12660                 return true;
12661               case 1: //src_1
12662                 return true;
12663               case 2: //vdst
12664                 return false;
12665               default:
12666                 fatal("op idx %i out of bounds\n", opIdx);
12667                 return false;
12668             }
12669         } // isSrcOperand
12670
12671         bool
12672         isDstOperand(int opIdx) override
12673         {
12674             switch (opIdx) {
12675               case 0: //src_0
12676                 return false;
12677               case 1: //src_1
12678                 return false;
12679               case 2: //vdst
12680                 return true;
12681               default:
12682                 fatal("op idx %i out of bounds\n", opIdx);
12683                 return false;
12684             }
12685         } // isDstOperand
12686
12687         void execute(GPUDynInstPtr) override;
12688     }; // Inst_VOP2__V_ASHRREV_I32
12689
12690     class Inst_VOP2__V_LSHLREV_B32 : public Inst_VOP2
12691     {
12692       public:
12693         Inst_VOP2__V_LSHLREV_B32(InFmt_VOP2*);
12694         ~Inst_VOP2__V_LSHLREV_B32();
12695
12696         int
12697         getNumOperands() override
12698         {
12699             return numDstRegOperands() + numSrcRegOperands();
12700         } // getNumOperands
12701
12702         int numDstRegOperands() override { return 1; }
12703         int numSrcRegOperands() override { return 2; }
12704
12705         int
12706         getOperandSize(int opIdx) override
12707         {
12708             switch (opIdx) {
12709               case 0: //src_0
12710                 return 4;
12711               case 1: //src_1
12712                 return 4;
12713               case 2: //vdst
12714                 return 4;
12715               default:
12716                 fatal("op idx %i out of bounds\n", opIdx);
12717                 return -1;
12718             }
12719         } // getOperandSize
12720
12721         bool
12722         isSrcOperand(int opIdx) override
12723         {
12724             switch (opIdx) {
12725               case 0: //src_0
12726                 return true;
12727               case 1: //src_1
12728                 return true;
12729               case 2: //vdst
12730                 return false;
12731               default:
12732                 fatal("op idx %i out of bounds\n", opIdx);
12733                 return false;
12734             }
12735         } // isSrcOperand
12736
12737         bool
12738         isDstOperand(int opIdx) override
12739         {
12740             switch (opIdx) {
12741               case 0: //src_0
12742                 return false;
12743               case 1: //src_1
12744                 return false;
12745               case 2: //vdst
12746                 return true;
12747               default:
12748                 fatal("op idx %i out of bounds\n", opIdx);
12749                 return false;
12750             }
12751         } // isDstOperand
12752
12753         void execute(GPUDynInstPtr) override;
12754     }; // Inst_VOP2__V_LSHLREV_B32
12755
12756     class Inst_VOP2__V_AND_B32 : public Inst_VOP2
12757     {
12758       public:
12759         Inst_VOP2__V_AND_B32(InFmt_VOP2*);
12760         ~Inst_VOP2__V_AND_B32();
12761
12762         int
12763         getNumOperands() override
12764         {
12765             return numDstRegOperands() + numSrcRegOperands();
12766         } // getNumOperands
12767
12768         int numDstRegOperands() override { return 1; }
12769         int numSrcRegOperands() override { return 2; }
12770
12771         int
12772         getOperandSize(int opIdx) override
12773         {
12774             switch (opIdx) {
12775               case 0: //src_0
12776                 return 4;
12777               case 1: //src_1
12778                 return 4;
12779               case 2: //vdst
12780                 return 4;
12781               default:
12782                 fatal("op idx %i out of bounds\n", opIdx);
12783                 return -1;
12784             }
12785         } // getOperandSize
12786
12787         bool
12788         isSrcOperand(int opIdx) override
12789         {
12790             switch (opIdx) {
12791               case 0: //src_0
12792                 return true;
12793               case 1: //src_1
12794                 return true;
12795               case 2: //vdst
12796                 return false;
12797               default:
12798                 fatal("op idx %i out of bounds\n", opIdx);
12799                 return false;
12800             }
12801         } // isSrcOperand
12802
12803         bool
12804         isDstOperand(int opIdx) override
12805         {
12806             switch (opIdx) {
12807               case 0: //src_0
12808                 return false;
12809               case 1: //src_1
12810                 return false;
12811               case 2: //vdst
12812                 return true;
12813               default:
12814                 fatal("op idx %i out of bounds\n", opIdx);
12815                 return false;
12816             }
12817         } // isDstOperand
12818
12819         void execute(GPUDynInstPtr) override;
12820     }; // Inst_VOP2__V_AND_B32
12821
12822     class Inst_VOP2__V_OR_B32 : public Inst_VOP2
12823     {
12824       public:
12825         Inst_VOP2__V_OR_B32(InFmt_VOP2*);
12826         ~Inst_VOP2__V_OR_B32();
12827
12828         int
12829         getNumOperands() override
12830         {
12831             return numDstRegOperands() + numSrcRegOperands();
12832         } // getNumOperands
12833
12834         int numDstRegOperands() override { return 1; }
12835         int numSrcRegOperands() override { return 2; }
12836
12837         int
12838         getOperandSize(int opIdx) override
12839         {
12840             switch (opIdx) {
12841               case 0: //src_0
12842                 return 4;
12843               case 1: //src_1
12844                 return 4;
12845               case 2: //vdst
12846                 return 4;
12847               default:
12848                 fatal("op idx %i out of bounds\n", opIdx);
12849                 return -1;
12850             }
12851         } // getOperandSize
12852
12853         bool
12854         isSrcOperand(int opIdx) override
12855         {
12856             switch (opIdx) {
12857               case 0: //src_0
12858                 return true;
12859               case 1: //src_1
12860                 return true;
12861               case 2: //vdst
12862                 return false;
12863               default:
12864                 fatal("op idx %i out of bounds\n", opIdx);
12865                 return false;
12866             }
12867         } // isSrcOperand
12868
12869         bool
12870         isDstOperand(int opIdx) override
12871         {
12872             switch (opIdx) {
12873               case 0: //src_0
12874                 return false;
12875               case 1: //src_1
12876                 return false;
12877               case 2: //vdst
12878                 return true;
12879               default:
12880                 fatal("op idx %i out of bounds\n", opIdx);
12881                 return false;
12882             }
12883         } // isDstOperand
12884
12885         void execute(GPUDynInstPtr) override;
12886     }; // Inst_VOP2__V_OR_B32
12887
12888     class Inst_VOP2__V_XOR_B32 : public Inst_VOP2
12889     {
12890       public:
12891         Inst_VOP2__V_XOR_B32(InFmt_VOP2*);
12892         ~Inst_VOP2__V_XOR_B32();
12893
12894         int
12895         getNumOperands() override
12896         {
12897             return numDstRegOperands() + numSrcRegOperands();
12898         } // getNumOperands
12899
12900         int numDstRegOperands() override { return 1; }
12901         int numSrcRegOperands() override { return 2; }
12902
12903         int
12904         getOperandSize(int opIdx) override
12905         {
12906             switch (opIdx) {
12907               case 0: //src_0
12908                 return 4;
12909               case 1: //src_1
12910                 return 4;
12911               case 2: //vdst
12912                 return 4;
12913               default:
12914                 fatal("op idx %i out of bounds\n", opIdx);
12915                 return -1;
12916             }
12917         } // getOperandSize
12918
12919         bool
12920         isSrcOperand(int opIdx) override
12921         {
12922             switch (opIdx) {
12923               case 0: //src_0
12924                 return true;
12925               case 1: //src_1
12926                 return true;
12927               case 2: //vdst
12928                 return false;
12929               default:
12930                 fatal("op idx %i out of bounds\n", opIdx);
12931                 return false;
12932             }
12933         } // isSrcOperand
12934
12935         bool
12936         isDstOperand(int opIdx) override
12937         {
12938             switch (opIdx) {
12939               case 0: //src_0
12940                 return false;
12941               case 1: //src_1
12942                 return false;
12943               case 2: //vdst
12944                 return true;
12945               default:
12946                 fatal("op idx %i out of bounds\n", opIdx);
12947                 return false;
12948             }
12949         } // isDstOperand
12950
12951         void execute(GPUDynInstPtr) override;
12952     }; // Inst_VOP2__V_XOR_B32
12953
12954     class Inst_VOP2__V_MAC_F32 : public Inst_VOP2
12955     {
12956       public:
12957         Inst_VOP2__V_MAC_F32(InFmt_VOP2*);
12958         ~Inst_VOP2__V_MAC_F32();
12959
12960         int
12961         getNumOperands() override
12962         {
12963             return numDstRegOperands() + numSrcRegOperands();
12964         } // getNumOperands
12965
12966         int numDstRegOperands() override { return 1; }
12967         int numSrcRegOperands() override { return 2; }
12968
12969         int
12970         getOperandSize(int opIdx) override
12971         {
12972             switch (opIdx) {
12973               case 0: //src_0
12974                 return 4;
12975               case 1: //src_1
12976                 return 4;
12977               case 2: //vdst
12978                 return 4;
12979               default:
12980                 fatal("op idx %i out of bounds\n", opIdx);
12981                 return -1;
12982             }
12983         } // getOperandSize
12984
12985         bool
12986         isSrcOperand(int opIdx) override
12987         {
12988             switch (opIdx) {
12989               case 0: //src_0
12990                 return true;
12991               case 1: //src_1
12992                 return true;
12993               case 2: //vdst
12994                 return false;
12995               default:
12996                 fatal("op idx %i out of bounds\n", opIdx);
12997                 return false;
12998             }
12999         } // isSrcOperand
13000
13001         bool
13002         isDstOperand(int opIdx) override
13003         {
13004             switch (opIdx) {
13005               case 0: //src_0
13006                 return false;
13007               case 1: //src_1
13008                 return false;
13009               case 2: //vdst
13010                 return true;
13011               default:
13012                 fatal("op idx %i out of bounds\n", opIdx);
13013                 return false;
13014             }
13015         } // isDstOperand
13016
13017         void execute(GPUDynInstPtr) override;
13018     }; // Inst_VOP2__V_MAC_F32
13019
13020     class Inst_VOP2__V_MADMK_F32 : public Inst_VOP2
13021     {
13022       public:
13023         Inst_VOP2__V_MADMK_F32(InFmt_VOP2*);
13024         ~Inst_VOP2__V_MADMK_F32();
13025
13026         int
13027         getNumOperands() override
13028         {
13029             return numDstRegOperands() + numSrcRegOperands();
13030         } // getNumOperands
13031
13032         int numDstRegOperands() override { return 1; }
13033         int numSrcRegOperands() override { return 2; }
13034
13035         int
13036         getOperandSize(int opIdx) override
13037         {
13038             switch (opIdx) {
13039               case 0: //src_0
13040                 return 4;
13041               case 1: //src_1
13042                 return 4;
13043               case 2: //vdst
13044                 return 4;
13045               default:
13046                 fatal("op idx %i out of bounds\n", opIdx);
13047                 return -1;
13048             }
13049         } // getOperandSize
13050
13051         bool
13052         isSrcOperand(int opIdx) override
13053         {
13054             switch (opIdx) {
13055               case 0: //src_0
13056                 return true;
13057               case 1: //src_1
13058                 return true;
13059               case 2: //vdst
13060                 return false;
13061               default:
13062                 fatal("op idx %i out of bounds\n", opIdx);
13063                 return false;
13064             }
13065         } // isSrcOperand
13066
13067         bool
13068         isDstOperand(int opIdx) override
13069         {
13070             switch (opIdx) {
13071               case 0: //src_0
13072                 return false;
13073               case 1: //src_1
13074                 return false;
13075               case 2: //vdst
13076                 return true;
13077               default:
13078                 fatal("op idx %i out of bounds\n", opIdx);
13079                 return false;
13080             }
13081         } // isDstOperand
13082
13083         void execute(GPUDynInstPtr) override;
13084     }; // Inst_VOP2__V_MADMK_F32
13085
13086     class Inst_VOP2__V_MADAK_F32 : public Inst_VOP2
13087     {
13088       public:
13089         Inst_VOP2__V_MADAK_F32(InFmt_VOP2*);
13090         ~Inst_VOP2__V_MADAK_F32();
13091
13092         int
13093         getNumOperands() override
13094         {
13095             return numDstRegOperands() + numSrcRegOperands();
13096         } // getNumOperands
13097
13098         int numDstRegOperands() override { return 1; }
13099         int numSrcRegOperands() override { return 2; }
13100
13101         int
13102         getOperandSize(int opIdx) override
13103         {
13104             switch (opIdx) {
13105               case 0: //src_0
13106                 return 4;
13107               case 1: //src_1
13108                 return 4;
13109               case 2: //vdst
13110                 return 4;
13111               default:
13112                 fatal("op idx %i out of bounds\n", opIdx);
13113                 return -1;
13114             }
13115         } // getOperandSize
13116
13117         bool
13118         isSrcOperand(int opIdx) override
13119         {
13120             switch (opIdx) {
13121               case 0: //src_0
13122                 return true;
13123               case 1: //src_1
13124                 return true;
13125               case 2: //vdst
13126                 return false;
13127               default:
13128                 fatal("op idx %i out of bounds\n", opIdx);
13129                 return false;
13130             }
13131         } // isSrcOperand
13132
13133         bool
13134         isDstOperand(int opIdx) override
13135         {
13136             switch (opIdx) {
13137               case 0: //src_0
13138                 return false;
13139               case 1: //src_1
13140                 return false;
13141               case 2: //vdst
13142                 return true;
13143               default:
13144                 fatal("op idx %i out of bounds\n", opIdx);
13145                 return false;
13146             }
13147         } // isDstOperand
13148
13149         void execute(GPUDynInstPtr) override;
13150     }; // Inst_VOP2__V_MADAK_F32
13151
13152     class Inst_VOP2__V_ADD_U32 : public Inst_VOP2
13153     {
13154       public:
13155         Inst_VOP2__V_ADD_U32(InFmt_VOP2*);
13156         ~Inst_VOP2__V_ADD_U32();
13157
13158         int
13159         getNumOperands() override
13160         {
13161             return numDstRegOperands() + numSrcRegOperands();
13162         } // getNumOperands
13163
13164         int numDstRegOperands() override { return 2; }
13165         int numSrcRegOperands() override { return 2; }
13166
13167         int
13168         getOperandSize(int opIdx) override
13169         {
13170             switch (opIdx) {
13171               case 0: //src_0
13172                 return 4;
13173               case 1: //src_1
13174                 return 4;
13175               case 2: //vdst
13176                 return 4;
13177               case 3: //vcc
13178                 return 8;
13179               default:
13180                 fatal("op idx %i out of bounds\n", opIdx);
13181                 return -1;
13182             }
13183         } // getOperandSize
13184
13185         bool
13186         isSrcOperand(int opIdx) override
13187         {
13188             switch (opIdx) {
13189               case 0: //src_0
13190                 return true;
13191               case 1: //src_1
13192                 return true;
13193               case 2: //vdst
13194                 return false;
13195               case 3: //vcc
13196                 return false;
13197               default:
13198                 fatal("op idx %i out of bounds\n", opIdx);
13199                 return false;
13200             }
13201         } // isSrcOperand
13202
13203         bool
13204         isDstOperand(int opIdx) override
13205         {
13206             switch (opIdx) {
13207               case 0: //src_0
13208                 return false;
13209               case 1: //src_1
13210                 return false;
13211               case 2: //vdst
13212                 return true;
13213               case 3: //vcc
13214                 return true;
13215               default:
13216                 fatal("op idx %i out of bounds\n", opIdx);
13217                 return false;
13218             }
13219         } // isDstOperand
13220
13221         void execute(GPUDynInstPtr) override;
13222     }; // Inst_VOP2__V_ADD_U32
13223
13224     class Inst_VOP2__V_SUB_U32 : public Inst_VOP2
13225     {
13226       public:
13227         Inst_VOP2__V_SUB_U32(InFmt_VOP2*);
13228         ~Inst_VOP2__V_SUB_U32();
13229
13230         int
13231         getNumOperands() override
13232         {
13233             return numDstRegOperands() + numSrcRegOperands();
13234         } // getNumOperands
13235
13236         int numDstRegOperands() override { return 2; }
13237         int numSrcRegOperands() override { return 2; }
13238
13239         int
13240         getOperandSize(int opIdx) override
13241         {
13242             switch (opIdx) {
13243               case 0: //src_0
13244                 return 4;
13245               case 1: //src_1
13246                 return 4;
13247               case 2: //vdst
13248                 return 4;
13249               case 3: //vcc
13250                 return 8;
13251               default:
13252                 fatal("op idx %i out of bounds\n", opIdx);
13253                 return -1;
13254             }
13255         } // getOperandSize
13256
13257         bool
13258         isSrcOperand(int opIdx) override
13259         {
13260             switch (opIdx) {
13261               case 0: //src_0
13262                 return true;
13263               case 1: //src_1
13264                 return true;
13265               case 2: //vdst
13266                 return false;
13267               case 3: //vcc
13268                 return false;
13269               default:
13270                 fatal("op idx %i out of bounds\n", opIdx);
13271                 return false;
13272             }
13273         } // isSrcOperand
13274
13275         bool
13276         isDstOperand(int opIdx) override
13277         {
13278             switch (opIdx) {
13279               case 0: //src_0
13280                 return false;
13281               case 1: //src_1
13282                 return false;
13283               case 2: //vdst
13284                 return true;
13285               case 3: //vcc
13286                 return true;
13287               default:
13288                 fatal("op idx %i out of bounds\n", opIdx);
13289                 return false;
13290             }
13291         } // isDstOperand
13292
13293         void execute(GPUDynInstPtr) override;
13294     }; // Inst_VOP2__V_SUB_U32
13295
13296     class Inst_VOP2__V_SUBREV_U32 : public Inst_VOP2
13297     {
13298       public:
13299         Inst_VOP2__V_SUBREV_U32(InFmt_VOP2*);
13300         ~Inst_VOP2__V_SUBREV_U32();
13301
13302         int
13303         getNumOperands() override
13304         {
13305             return numDstRegOperands() + numSrcRegOperands();
13306         } // getNumOperands
13307
13308         int numDstRegOperands() override { return 2; }
13309         int numSrcRegOperands() override { return 2; }
13310
13311         int
13312         getOperandSize(int opIdx) override
13313         {
13314             switch (opIdx) {
13315               case 0: //src_0
13316                 return 4;
13317               case 1: //src_1
13318                 return 4;
13319               case 2: //vdst
13320                 return 4;
13321               case 3: //vcc
13322                 return 8;
13323               default:
13324                 fatal("op idx %i out of bounds\n", opIdx);
13325                 return -1;
13326             }
13327         } // getOperandSize
13328
13329         bool
13330         isSrcOperand(int opIdx) override
13331         {
13332             switch (opIdx) {
13333               case 0: //src_0
13334                 return true;
13335               case 1: //src_1
13336                 return true;
13337               case 2: //vdst
13338                 return false;
13339               case 3: //vcc
13340                 return false;
13341               default:
13342                 fatal("op idx %i out of bounds\n", opIdx);
13343                 return false;
13344             }
13345         } // isSrcOperand
13346
13347         bool
13348         isDstOperand(int opIdx) override
13349         {
13350             switch (opIdx) {
13351               case 0: //src_0
13352                 return false;
13353               case 1: //src_1
13354                 return false;
13355               case 2: //vdst
13356                 return true;
13357               case 3: //vcc
13358                 return true;
13359               default:
13360                 fatal("op idx %i out of bounds\n", opIdx);
13361                 return false;
13362             }
13363         } // isDstOperand
13364
13365         void execute(GPUDynInstPtr) override;
13366     }; // Inst_VOP2__V_SUBREV_U32
13367
13368     class Inst_VOP2__V_ADDC_U32 : public Inst_VOP2
13369     {
13370       public:
13371         Inst_VOP2__V_ADDC_U32(InFmt_VOP2*);
13372         ~Inst_VOP2__V_ADDC_U32();
13373
13374         int
13375         getNumOperands() override
13376         {
13377             return numDstRegOperands() + numSrcRegOperands();
13378         } // getNumOperands
13379
13380         int numDstRegOperands() override { return 2; }
13381         int numSrcRegOperands() override { return 3; }
13382
13383         int
13384         getOperandSize(int opIdx) override
13385         {
13386             switch (opIdx) {
13387               case 0: //src_0
13388                 return 4;
13389               case 1: //src_1
13390                 return 4;
13391               case 2: //vcc
13392                 return 8;
13393               case 3: //vdst
13394                 return 4;
13395               case 4: //vcc
13396                 return 8;
13397               default:
13398                 fatal("op idx %i out of bounds\n", opIdx);
13399                 return -1;
13400             }
13401         } // getOperandSize
13402
13403         bool
13404         isSrcOperand(int opIdx) override
13405         {
13406             switch (opIdx) {
13407               case 0: //src_0
13408                 return true;
13409               case 1: //src_1
13410                 return true;
13411               case 2: //vcc
13412                 return true;
13413               case 3: //vdst
13414                 return false;
13415               case 4: //vcc
13416                 return false;
13417               default:
13418                 fatal("op idx %i out of bounds\n", opIdx);
13419                 return false;
13420             }
13421         } // isSrcOperand
13422
13423         bool
13424         isDstOperand(int opIdx) override
13425         {
13426             switch (opIdx) {
13427               case 0: //src_0
13428                 return false;
13429               case 1: //src_1
13430                 return false;
13431               case 2: //vcc
13432                 return false;
13433               case 3: //vdst
13434                 return true;
13435               case 4: //vcc
13436                 return true;
13437               default:
13438                 fatal("op idx %i out of bounds\n", opIdx);
13439                 return false;
13440             }
13441         } // isDstOperand
13442
13443         void execute(GPUDynInstPtr) override;
13444     }; // Inst_VOP2__V_ADDC_U32
13445
13446     class Inst_VOP2__V_SUBB_U32 : public Inst_VOP2
13447     {
13448       public:
13449         Inst_VOP2__V_SUBB_U32(InFmt_VOP2*);
13450         ~Inst_VOP2__V_SUBB_U32();
13451
13452         int
13453         getNumOperands() override
13454         {
13455             return numDstRegOperands() + numSrcRegOperands();
13456         } // getNumOperands
13457
13458         int numDstRegOperands() override { return 2; }
13459         int numSrcRegOperands() override { return 3; }
13460
13461         int
13462         getOperandSize(int opIdx) override
13463         {
13464             switch (opIdx) {
13465               case 0: //src_0
13466                 return 4;
13467               case 1: //src_1
13468                 return 4;
13469               case 2: //vcc
13470                 return 8;
13471               case 3: //vdst
13472                 return 4;
13473               case 4: //vcc
13474                 return 8;
13475               default:
13476                 fatal("op idx %i out of bounds\n", opIdx);
13477                 return -1;
13478             }
13479         } // getOperandSize
13480
13481         bool
13482         isSrcOperand(int opIdx) override
13483         {
13484             switch (opIdx) {
13485               case 0: //src_0
13486                 return true;
13487               case 1: //src_1
13488                 return true;
13489               case 2: //vcc
13490                 return true;
13491               case 3: //vdst
13492                 return false;
13493               case 4: //vcc
13494                 return false;
13495               default:
13496                 fatal("op idx %i out of bounds\n", opIdx);
13497                 return false;
13498             }
13499         } // isSrcOperand
13500
13501         bool
13502         isDstOperand(int opIdx) override
13503         {
13504             switch (opIdx) {
13505               case 0: //src_0
13506                 return false;
13507               case 1: //src_1
13508                 return false;
13509               case 2: //vcc
13510                 return false;
13511               case 3: //vdst
13512                 return true;
13513               case 4: //vcc
13514                 return true;
13515               default:
13516                 fatal("op idx %i out of bounds\n", opIdx);
13517                 return false;
13518             }
13519         } // isDstOperand
13520
13521         void execute(GPUDynInstPtr) override;
13522     }; // Inst_VOP2__V_SUBB_U32
13523
13524     class Inst_VOP2__V_SUBBREV_U32 : public Inst_VOP2
13525     {
13526       public:
13527         Inst_VOP2__V_SUBBREV_U32(InFmt_VOP2*);
13528         ~Inst_VOP2__V_SUBBREV_U32();
13529
13530         int
13531         getNumOperands() override
13532         {
13533             return numDstRegOperands() + numSrcRegOperands();
13534         } // getNumOperands
13535
13536         int numDstRegOperands() override { return 2; }
13537         int numSrcRegOperands() override { return 3; }
13538
13539         int
13540         getOperandSize(int opIdx) override
13541         {
13542             switch (opIdx) {
13543               case 0: //src_0
13544                 return 4;
13545               case 1: //src_1
13546                 return 4;
13547               case 2: //vcc
13548                 return 8;
13549               case 3: //vdst
13550                 return 4;
13551               case 4: //vcc
13552                 return 8;
13553               default:
13554                 fatal("op idx %i out of bounds\n", opIdx);
13555                 return -1;
13556             }
13557         } // getOperandSize
13558
13559         bool
13560         isSrcOperand(int opIdx) override
13561         {
13562             switch (opIdx) {
13563               case 0: //src_0
13564                 return true;
13565               case 1: //src_1
13566                 return true;
13567               case 2: //vcc
13568                 return true;
13569               case 3: //vdst
13570                 return false;
13571               case 4: //vcc
13572                 return false;
13573               default:
13574                 fatal("op idx %i out of bounds\n", opIdx);
13575                 return false;
13576             }
13577         } // isSrcOperand
13578
13579         bool
13580         isDstOperand(int opIdx) override
13581         {
13582             switch (opIdx) {
13583               case 0: //src_0
13584                 return false;
13585               case 1: //src_1
13586                 return false;
13587               case 2: //vcc
13588                 return false;
13589               case 3: //vdst
13590                 return true;
13591               case 4: //vcc
13592                 return true;
13593               default:
13594                 fatal("op idx %i out of bounds\n", opIdx);
13595                 return false;
13596             }
13597         } // isDstOperand
13598
13599         void execute(GPUDynInstPtr) override;
13600     }; // Inst_VOP2__V_SUBBREV_U32
13601
13602     class Inst_VOP2__V_ADD_F16 : public Inst_VOP2
13603     {
13604       public:
13605         Inst_VOP2__V_ADD_F16(InFmt_VOP2*);
13606         ~Inst_VOP2__V_ADD_F16();
13607
13608         int
13609         getNumOperands() override
13610         {
13611             return numDstRegOperands() + numSrcRegOperands();
13612         } // getNumOperands
13613
13614         int numDstRegOperands() override { return 1; }
13615         int numSrcRegOperands() override { return 2; }
13616
13617         int
13618         getOperandSize(int opIdx) override
13619         {
13620             switch (opIdx) {
13621               case 0: //src_0
13622                 return 2;
13623               case 1: //src_1
13624                 return 2;
13625               case 2: //vdst
13626                 return 2;
13627               default:
13628                 fatal("op idx %i out of bounds\n", opIdx);
13629                 return -1;
13630             }
13631         } // getOperandSize
13632
13633         bool
13634         isSrcOperand(int opIdx) override
13635         {
13636             switch (opIdx) {
13637               case 0: //src_0
13638                 return true;
13639               case 1: //src_1
13640                 return true;
13641               case 2: //vdst
13642                 return false;
13643               default:
13644                 fatal("op idx %i out of bounds\n", opIdx);
13645                 return false;
13646             }
13647         } // isSrcOperand
13648
13649         bool
13650         isDstOperand(int opIdx) override
13651         {
13652             switch (opIdx) {
13653               case 0: //src_0
13654                 return false;
13655               case 1: //src_1
13656                 return false;
13657               case 2: //vdst
13658                 return true;
13659               default:
13660                 fatal("op idx %i out of bounds\n", opIdx);
13661                 return false;
13662             }
13663         } // isDstOperand
13664
13665         void execute(GPUDynInstPtr) override;
13666     }; // Inst_VOP2__V_ADD_F16
13667
13668     class Inst_VOP2__V_SUB_F16 : public Inst_VOP2
13669     {
13670       public:
13671         Inst_VOP2__V_SUB_F16(InFmt_VOP2*);
13672         ~Inst_VOP2__V_SUB_F16();
13673
13674         int
13675         getNumOperands() override
13676         {
13677             return numDstRegOperands() + numSrcRegOperands();
13678         } // getNumOperands
13679
13680         int numDstRegOperands() override { return 1; }
13681         int numSrcRegOperands() override { return 2; }
13682
13683         int
13684         getOperandSize(int opIdx) override
13685         {
13686             switch (opIdx) {
13687               case 0: //src_0
13688                 return 2;
13689               case 1: //src_1
13690                 return 2;
13691               case 2: //vdst
13692                 return 2;
13693               default:
13694                 fatal("op idx %i out of bounds\n", opIdx);
13695                 return -1;
13696             }
13697         } // getOperandSize
13698
13699         bool
13700         isSrcOperand(int opIdx) override
13701         {
13702             switch (opIdx) {
13703               case 0: //src_0
13704                 return true;
13705               case 1: //src_1
13706                 return true;
13707               case 2: //vdst
13708                 return false;
13709               default:
13710                 fatal("op idx %i out of bounds\n", opIdx);
13711                 return false;
13712             }
13713         } // isSrcOperand
13714
13715         bool
13716         isDstOperand(int opIdx) override
13717         {
13718             switch (opIdx) {
13719               case 0: //src_0
13720                 return false;
13721               case 1: //src_1
13722                 return false;
13723               case 2: //vdst
13724                 return true;
13725               default:
13726                 fatal("op idx %i out of bounds\n", opIdx);
13727                 return false;
13728             }
13729         } // isDstOperand
13730
13731         void execute(GPUDynInstPtr) override;
13732     }; // Inst_VOP2__V_SUB_F16
13733
13734     class Inst_VOP2__V_SUBREV_F16 : public Inst_VOP2
13735     {
13736       public:
13737         Inst_VOP2__V_SUBREV_F16(InFmt_VOP2*);
13738         ~Inst_VOP2__V_SUBREV_F16();
13739
13740         int
13741         getNumOperands() override
13742         {
13743             return numDstRegOperands() + numSrcRegOperands();
13744         } // getNumOperands
13745
13746         int numDstRegOperands() override { return 1; }
13747         int numSrcRegOperands() override { return 2; }
13748
13749         int
13750         getOperandSize(int opIdx) override
13751         {
13752             switch (opIdx) {
13753               case 0: //src_0
13754                 return 2;
13755               case 1: //src_1
13756                 return 2;
13757               case 2: //vdst
13758                 return 2;
13759               default:
13760                 fatal("op idx %i out of bounds\n", opIdx);
13761                 return -1;
13762             }
13763         } // getOperandSize
13764
13765         bool
13766         isSrcOperand(int opIdx) override
13767         {
13768             switch (opIdx) {
13769               case 0: //src_0
13770                 return true;
13771               case 1: //src_1
13772                 return true;
13773               case 2: //vdst
13774                 return false;
13775               default:
13776                 fatal("op idx %i out of bounds\n", opIdx);
13777                 return false;
13778             }
13779         } // isSrcOperand
13780
13781         bool
13782         isDstOperand(int opIdx) override
13783         {
13784             switch (opIdx) {
13785               case 0: //src_0
13786                 return false;
13787               case 1: //src_1
13788                 return false;
13789               case 2: //vdst
13790                 return true;
13791               default:
13792                 fatal("op idx %i out of bounds\n", opIdx);
13793                 return false;
13794             }
13795         } // isDstOperand
13796
13797         void execute(GPUDynInstPtr) override;
13798     }; // Inst_VOP2__V_SUBREV_F16
13799
13800     class Inst_VOP2__V_MUL_F16 : public Inst_VOP2
13801     {
13802       public:
13803         Inst_VOP2__V_MUL_F16(InFmt_VOP2*);
13804         ~Inst_VOP2__V_MUL_F16();
13805
13806         int
13807         getNumOperands() override
13808         {
13809             return numDstRegOperands() + numSrcRegOperands();
13810         } // getNumOperands
13811
13812         int numDstRegOperands() override { return 1; }
13813         int numSrcRegOperands() override { return 2; }
13814
13815         int
13816         getOperandSize(int opIdx) override
13817         {
13818             switch (opIdx) {
13819               case 0: //src_0
13820                 return 2;
13821               case 1: //src_1
13822                 return 2;
13823               case 2: //vdst
13824                 return 2;
13825               default:
13826                 fatal("op idx %i out of bounds\n", opIdx);
13827                 return -1;
13828             }
13829         } // getOperandSize
13830
13831         bool
13832         isSrcOperand(int opIdx) override
13833         {
13834             switch (opIdx) {
13835               case 0: //src_0
13836                 return true;
13837               case 1: //src_1
13838                 return true;
13839               case 2: //vdst
13840                 return false;
13841               default:
13842                 fatal("op idx %i out of bounds\n", opIdx);
13843                 return false;
13844             }
13845         } // isSrcOperand
13846
13847         bool
13848         isDstOperand(int opIdx) override
13849         {
13850             switch (opIdx) {
13851               case 0: //src_0
13852                 return false;
13853               case 1: //src_1
13854                 return false;
13855               case 2: //vdst
13856                 return true;
13857               default:
13858                 fatal("op idx %i out of bounds\n", opIdx);
13859                 return false;
13860             }
13861         } // isDstOperand
13862
13863         void execute(GPUDynInstPtr) override;
13864     }; // Inst_VOP2__V_MUL_F16
13865
13866     class Inst_VOP2__V_MAC_F16 : public Inst_VOP2
13867     {
13868       public:
13869         Inst_VOP2__V_MAC_F16(InFmt_VOP2*);
13870         ~Inst_VOP2__V_MAC_F16();
13871
13872         int
13873         getNumOperands() override
13874         {
13875             return numDstRegOperands() + numSrcRegOperands();
13876         } // getNumOperands
13877
13878         int numDstRegOperands() override { return 1; }
13879         int numSrcRegOperands() override { return 2; }
13880
13881         int
13882         getOperandSize(int opIdx) override
13883         {
13884             switch (opIdx) {
13885               case 0: //src_0
13886                 return 2;
13887               case 1: //src_1
13888                 return 2;
13889               case 2: //vdst
13890                 return 2;
13891               default:
13892                 fatal("op idx %i out of bounds\n", opIdx);
13893                 return -1;
13894             }
13895         } // getOperandSize
13896
13897         bool
13898         isSrcOperand(int opIdx) override
13899         {
13900             switch (opIdx) {
13901               case 0: //src_0
13902                 return true;
13903               case 1: //src_1
13904                 return true;
13905               case 2: //vdst
13906                 return false;
13907               default:
13908                 fatal("op idx %i out of bounds\n", opIdx);
13909                 return false;
13910             }
13911         } // isSrcOperand
13912
13913         bool
13914         isDstOperand(int opIdx) override
13915         {
13916             switch (opIdx) {
13917               case 0: //src_0
13918                 return false;
13919               case 1: //src_1
13920                 return false;
13921               case 2: //vdst
13922                 return true;
13923               default:
13924                 fatal("op idx %i out of bounds\n", opIdx);
13925                 return false;
13926             }
13927         } // isDstOperand
13928
13929         void execute(GPUDynInstPtr) override;
13930     }; // Inst_VOP2__V_MAC_F16
13931
13932     class Inst_VOP2__V_MADMK_F16 : public Inst_VOP2
13933     {
13934       public:
13935         Inst_VOP2__V_MADMK_F16(InFmt_VOP2*);
13936         ~Inst_VOP2__V_MADMK_F16();
13937
13938         int
13939         getNumOperands() override
13940         {
13941             return numDstRegOperands() + numSrcRegOperands();
13942         } // getNumOperands
13943
13944         int numDstRegOperands() override { return 1; }
13945         int numSrcRegOperands() override { return 3; }
13946
13947         int
13948         getOperandSize(int opIdx) override
13949         {
13950             switch (opIdx) {
13951               case 0: //src_0
13952                 return 2;
13953               case 1: //src_1
13954                 return 2;
13955               case 2: //src_2
13956                 return 2;
13957               case 3: //vdst
13958                 return 2;
13959               default:
13960                 fatal("op idx %i out of bounds\n", opIdx);
13961                 return -1;
13962             }
13963         } // getOperandSize
13964
13965         bool
13966         isSrcOperand(int opIdx) override
13967         {
13968             switch (opIdx) {
13969               case 0: //src_0
13970                 return true;
13971               case 1: //src_1
13972                 return true;
13973               case 2: //src_2
13974                 return true;
13975               case 3: //vdst
13976                 return false;
13977               default:
13978                 fatal("op idx %i out of bounds\n", opIdx);
13979                 return false;
13980             }
13981         } // isSrcOperand
13982
13983         bool
13984         isDstOperand(int opIdx) override
13985         {
13986             switch (opIdx) {
13987               case 0: //src_0
13988                 return false;
13989               case 1: //src_1
13990                 return false;
13991               case 2: //src_2
13992                 return false;
13993               case 3: //vdst
13994                 return true;
13995               default:
13996                 fatal("op idx %i out of bounds\n", opIdx);
13997                 return false;
13998             }
13999         } // isDstOperand
14000
14001         void execute(GPUDynInstPtr) override;
14002     }; // Inst_VOP2__V_MADMK_F16
14003
14004     class Inst_VOP2__V_MADAK_F16 : public Inst_VOP2
14005     {
14006       public:
14007         Inst_VOP2__V_MADAK_F16(InFmt_VOP2*);
14008         ~Inst_VOP2__V_MADAK_F16();
14009
14010         int
14011         getNumOperands() override
14012         {
14013             return numDstRegOperands() + numSrcRegOperands();
14014         } // getNumOperands
14015
14016         int numDstRegOperands() override { return 1; }
14017         int numSrcRegOperands() override { return 3; }
14018
14019         int
14020         getOperandSize(int opIdx) override
14021         {
14022             switch (opIdx) {
14023               case 0: //src_0
14024                 return 2;
14025               case 1: //src_1
14026                 return 2;
14027               case 2: //src_2
14028                 return 2;
14029               case 3: //vdst
14030                 return 2;
14031               default:
14032                 fatal("op idx %i out of bounds\n", opIdx);
14033                 return -1;
14034             }
14035         } // getOperandSize
14036
14037         bool
14038         isSrcOperand(int opIdx) override
14039         {
14040             switch (opIdx) {
14041               case 0: //src_0
14042                 return true;
14043               case 1: //src_1
14044                 return true;
14045               case 2: //src_2
14046                 return true;
14047               case 3: //vdst
14048                 return false;
14049               default:
14050                 fatal("op idx %i out of bounds\n", opIdx);
14051                 return false;
14052             }
14053         } // isSrcOperand
14054
14055         bool
14056         isDstOperand(int opIdx) override
14057         {
14058             switch (opIdx) {
14059               case 0: //src_0
14060                 return false;
14061               case 1: //src_1
14062                 return false;
14063               case 2: //src_2
14064                 return false;
14065               case 3: //vdst
14066                 return true;
14067               default:
14068                 fatal("op idx %i out of bounds\n", opIdx);
14069                 return false;
14070             }
14071         } // isDstOperand
14072
14073         void execute(GPUDynInstPtr) override;
14074     }; // Inst_VOP2__V_MADAK_F16
14075
14076     class Inst_VOP2__V_ADD_U16 : public Inst_VOP2
14077     {
14078       public:
14079         Inst_VOP2__V_ADD_U16(InFmt_VOP2*);
14080         ~Inst_VOP2__V_ADD_U16();
14081
14082         int
14083         getNumOperands() override
14084         {
14085             return numDstRegOperands() + numSrcRegOperands();
14086         } // getNumOperands
14087
14088         int numDstRegOperands() override { return 1; }
14089         int numSrcRegOperands() override { return 2; }
14090
14091         int
14092         getOperandSize(int opIdx) override
14093         {
14094             switch (opIdx) {
14095               case 0: //src_0
14096                 return 2;
14097               case 1: //src_1
14098                 return 2;
14099               case 2: //vdst
14100                 return 2;
14101               default:
14102                 fatal("op idx %i out of bounds\n", opIdx);
14103                 return -1;
14104             }
14105         } // getOperandSize
14106
14107         bool
14108         isSrcOperand(int opIdx) override
14109         {
14110             switch (opIdx) {
14111               case 0: //src_0
14112                 return true;
14113               case 1: //src_1
14114                 return true;
14115               case 2: //vdst
14116                 return false;
14117               default:
14118                 fatal("op idx %i out of bounds\n", opIdx);
14119                 return false;
14120             }
14121         } // isSrcOperand
14122
14123         bool
14124         isDstOperand(int opIdx) override
14125         {
14126             switch (opIdx) {
14127               case 0: //src_0
14128                 return false;
14129               case 1: //src_1
14130                 return false;
14131               case 2: //vdst
14132                 return true;
14133               default:
14134                 fatal("op idx %i out of bounds\n", opIdx);
14135                 return false;
14136             }
14137         } // isDstOperand
14138
14139         void execute(GPUDynInstPtr) override;
14140     }; // Inst_VOP2__V_ADD_U16
14141
14142     class Inst_VOP2__V_SUB_U16 : public Inst_VOP2
14143     {
14144       public:
14145         Inst_VOP2__V_SUB_U16(InFmt_VOP2*);
14146         ~Inst_VOP2__V_SUB_U16();
14147
14148         int
14149         getNumOperands() override
14150         {
14151             return numDstRegOperands() + numSrcRegOperands();
14152         } // getNumOperands
14153
14154         int numDstRegOperands() override { return 1; }
14155         int numSrcRegOperands() override { return 2; }
14156
14157         int
14158         getOperandSize(int opIdx) override
14159         {
14160             switch (opIdx) {
14161               case 0: //src_0
14162                 return 2;
14163               case 1: //src_1
14164                 return 2;
14165               case 2: //vdst
14166                 return 2;
14167               default:
14168                 fatal("op idx %i out of bounds\n", opIdx);
14169                 return -1;
14170             }
14171         } // getOperandSize
14172
14173         bool
14174         isSrcOperand(int opIdx) override
14175         {
14176             switch (opIdx) {
14177               case 0: //src_0
14178                 return true;
14179               case 1: //src_1
14180                 return true;
14181               case 2: //vdst
14182                 return false;
14183               default:
14184                 fatal("op idx %i out of bounds\n", opIdx);
14185                 return false;
14186             }
14187         } // isSrcOperand
14188
14189         bool
14190         isDstOperand(int opIdx) override
14191         {
14192             switch (opIdx) {
14193               case 0: //src_0
14194                 return false;
14195               case 1: //src_1
14196                 return false;
14197               case 2: //vdst
14198                 return true;
14199               default:
14200                 fatal("op idx %i out of bounds\n", opIdx);
14201                 return false;
14202             }
14203         } // isDstOperand
14204
14205         void execute(GPUDynInstPtr) override;
14206     }; // Inst_VOP2__V_SUB_U16
14207
14208     class Inst_VOP2__V_SUBREV_U16 : public Inst_VOP2
14209     {
14210       public:
14211         Inst_VOP2__V_SUBREV_U16(InFmt_VOP2*);
14212         ~Inst_VOP2__V_SUBREV_U16();
14213
14214         int
14215         getNumOperands() override
14216         {
14217             return numDstRegOperands() + numSrcRegOperands();
14218         } // getNumOperands
14219
14220         int numDstRegOperands() override { return 1; }
14221         int numSrcRegOperands() override { return 2; }
14222
14223         int
14224         getOperandSize(int opIdx) override
14225         {
14226             switch (opIdx) {
14227               case 0: //src_0
14228                 return 2;
14229               case 1: //src_1
14230                 return 2;
14231               case 2: //vdst
14232                 return 2;
14233               default:
14234                 fatal("op idx %i out of bounds\n", opIdx);
14235                 return -1;
14236             }
14237         } // getOperandSize
14238
14239         bool
14240         isSrcOperand(int opIdx) override
14241         {
14242             switch (opIdx) {
14243               case 0: //src_0
14244                 return true;
14245               case 1: //src_1
14246                 return true;
14247               case 2: //vdst
14248                 return false;
14249               default:
14250                 fatal("op idx %i out of bounds\n", opIdx);
14251                 return false;
14252             }
14253         } // isSrcOperand
14254
14255         bool
14256         isDstOperand(int opIdx) override
14257         {
14258             switch (opIdx) {
14259               case 0: //src_0
14260                 return false;
14261               case 1: //src_1
14262                 return false;
14263               case 2: //vdst
14264                 return true;
14265               default:
14266                 fatal("op idx %i out of bounds\n", opIdx);
14267                 return false;
14268             }
14269         } // isDstOperand
14270
14271         void execute(GPUDynInstPtr) override;
14272     }; // Inst_VOP2__V_SUBREV_U16
14273
14274     class Inst_VOP2__V_MUL_LO_U16 : public Inst_VOP2
14275     {
14276       public:
14277         Inst_VOP2__V_MUL_LO_U16(InFmt_VOP2*);
14278         ~Inst_VOP2__V_MUL_LO_U16();
14279
14280         int
14281         getNumOperands() override
14282         {
14283             return numDstRegOperands() + numSrcRegOperands();
14284         } // getNumOperands
14285
14286         int numDstRegOperands() override { return 1; }
14287         int numSrcRegOperands() override { return 2; }
14288
14289         int
14290         getOperandSize(int opIdx) override
14291         {
14292             switch (opIdx) {
14293               case 0: //src_0
14294                 return 2;
14295               case 1: //src_1
14296                 return 2;
14297               case 2: //vdst
14298                 return 2;
14299               default:
14300                 fatal("op idx %i out of bounds\n", opIdx);
14301                 return -1;
14302             }
14303         } // getOperandSize
14304
14305         bool
14306         isSrcOperand(int opIdx) override
14307         {
14308             switch (opIdx) {
14309               case 0: //src_0
14310                 return true;
14311               case 1: //src_1
14312                 return true;
14313               case 2: //vdst
14314                 return false;
14315               default:
14316                 fatal("op idx %i out of bounds\n", opIdx);
14317                 return false;
14318             }
14319         } // isSrcOperand
14320
14321         bool
14322         isDstOperand(int opIdx) override
14323         {
14324             switch (opIdx) {
14325               case 0: //src_0
14326                 return false;
14327               case 1: //src_1
14328                 return false;
14329               case 2: //vdst
14330                 return true;
14331               default:
14332                 fatal("op idx %i out of bounds\n", opIdx);
14333                 return false;
14334             }
14335         } // isDstOperand
14336
14337         void execute(GPUDynInstPtr) override;
14338     }; // Inst_VOP2__V_MUL_LO_U16
14339
14340     class Inst_VOP2__V_LSHLREV_B16 : public Inst_VOP2
14341     {
14342       public:
14343         Inst_VOP2__V_LSHLREV_B16(InFmt_VOP2*);
14344         ~Inst_VOP2__V_LSHLREV_B16();
14345
14346         int
14347         getNumOperands() override
14348         {
14349             return numDstRegOperands() + numSrcRegOperands();
14350         } // getNumOperands
14351
14352         int numDstRegOperands() override { return 1; }
14353         int numSrcRegOperands() override { return 2; }
14354
14355         int
14356         getOperandSize(int opIdx) override
14357         {
14358             switch (opIdx) {
14359               case 0: //src_0
14360                 return 2;
14361               case 1: //src_1
14362                 return 2;
14363               case 2: //vdst
14364                 return 2;
14365               default:
14366                 fatal("op idx %i out of bounds\n", opIdx);
14367                 return -1;
14368             }
14369         } // getOperandSize
14370
14371         bool
14372         isSrcOperand(int opIdx) override
14373         {
14374             switch (opIdx) {
14375               case 0: //src_0
14376                 return true;
14377               case 1: //src_1
14378                 return true;
14379               case 2: //vdst
14380                 return false;
14381               default:
14382                 fatal("op idx %i out of bounds\n", opIdx);
14383                 return false;
14384             }
14385         } // isSrcOperand
14386
14387         bool
14388         isDstOperand(int opIdx) override
14389         {
14390             switch (opIdx) {
14391               case 0: //src_0
14392                 return false;
14393               case 1: //src_1
14394                 return false;
14395               case 2: //vdst
14396                 return true;
14397               default:
14398                 fatal("op idx %i out of bounds\n", opIdx);
14399                 return false;
14400             }
14401         } // isDstOperand
14402
14403         void execute(GPUDynInstPtr) override;
14404     }; // Inst_VOP2__V_LSHLREV_B16
14405
14406     class Inst_VOP2__V_LSHRREV_B16 : public Inst_VOP2
14407     {
14408       public:
14409         Inst_VOP2__V_LSHRREV_B16(InFmt_VOP2*);
14410         ~Inst_VOP2__V_LSHRREV_B16();
14411
14412         int
14413         getNumOperands() override
14414         {
14415             return numDstRegOperands() + numSrcRegOperands();
14416         } // getNumOperands
14417
14418         int numDstRegOperands() override { return 1; }
14419         int numSrcRegOperands() override { return 2; }
14420
14421         int
14422         getOperandSize(int opIdx) override
14423         {
14424             switch (opIdx) {
14425               case 0: //src_0
14426                 return 2;
14427               case 1: //src_1
14428                 return 2;
14429               case 2: //vdst
14430                 return 2;
14431               default:
14432                 fatal("op idx %i out of bounds\n", opIdx);
14433                 return -1;
14434             }
14435         } // getOperandSize
14436
14437         bool
14438         isSrcOperand(int opIdx) override
14439         {
14440             switch (opIdx) {
14441               case 0: //src_0
14442                 return true;
14443               case 1: //src_1
14444                 return true;
14445               case 2: //vdst
14446                 return false;
14447               default:
14448                 fatal("op idx %i out of bounds\n", opIdx);
14449                 return false;
14450             }
14451         } // isSrcOperand
14452
14453         bool
14454         isDstOperand(int opIdx) override
14455         {
14456             switch (opIdx) {
14457               case 0: //src_0
14458                 return false;
14459               case 1: //src_1
14460                 return false;
14461               case 2: //vdst
14462                 return true;
14463               default:
14464                 fatal("op idx %i out of bounds\n", opIdx);
14465                 return false;
14466             }
14467         } // isDstOperand
14468
14469         void execute(GPUDynInstPtr) override;
14470     }; // Inst_VOP2__V_LSHRREV_B16
14471
14472     class Inst_VOP2__V_ASHRREV_I16 : public Inst_VOP2
14473     {
14474       public:
14475         Inst_VOP2__V_ASHRREV_I16(InFmt_VOP2*);
14476         ~Inst_VOP2__V_ASHRREV_I16();
14477
14478         int
14479         getNumOperands() override
14480         {
14481             return numDstRegOperands() + numSrcRegOperands();
14482         } // getNumOperands
14483
14484         int numDstRegOperands() override { return 1; }
14485         int numSrcRegOperands() override { return 2; }
14486
14487         int
14488         getOperandSize(int opIdx) override
14489         {
14490             switch (opIdx) {
14491               case 0: //src_0
14492                 return 2;
14493               case 1: //src_1
14494                 return 2;
14495               case 2: //vdst
14496                 return 2;
14497               default:
14498                 fatal("op idx %i out of bounds\n", opIdx);
14499                 return -1;
14500             }
14501         } // getOperandSize
14502
14503         bool
14504         isSrcOperand(int opIdx) override
14505         {
14506             switch (opIdx) {
14507               case 0: //src_0
14508                 return true;
14509               case 1: //src_1
14510                 return true;
14511               case 2: //vdst
14512                 return false;
14513               default:
14514                 fatal("op idx %i out of bounds\n", opIdx);
14515                 return false;
14516             }
14517         } // isSrcOperand
14518
14519         bool
14520         isDstOperand(int opIdx) override
14521         {
14522             switch (opIdx) {
14523               case 0: //src_0
14524                 return false;
14525               case 1: //src_1
14526                 return false;
14527               case 2: //vdst
14528                 return true;
14529               default:
14530                 fatal("op idx %i out of bounds\n", opIdx);
14531                 return false;
14532             }
14533         } // isDstOperand
14534
14535         void execute(GPUDynInstPtr) override;
14536     }; // Inst_VOP2__V_ASHRREV_I16
14537
14538     class Inst_VOP2__V_MAX_F16 : public Inst_VOP2
14539     {
14540       public:
14541         Inst_VOP2__V_MAX_F16(InFmt_VOP2*);
14542         ~Inst_VOP2__V_MAX_F16();
14543
14544         int
14545         getNumOperands() override
14546         {
14547             return numDstRegOperands() + numSrcRegOperands();
14548         } // getNumOperands
14549
14550         int numDstRegOperands() override { return 1; }
14551         int numSrcRegOperands() override { return 2; }
14552
14553         int
14554         getOperandSize(int opIdx) override
14555         {
14556             switch (opIdx) {
14557               case 0: //src_0
14558                 return 2;
14559               case 1: //src_1
14560                 return 2;
14561               case 2: //vdst
14562                 return 2;
14563               default:
14564                 fatal("op idx %i out of bounds\n", opIdx);
14565                 return -1;
14566             }
14567         } // getOperandSize
14568
14569         bool
14570         isSrcOperand(int opIdx) override
14571         {
14572             switch (opIdx) {
14573               case 0: //src_0
14574                 return true;
14575               case 1: //src_1
14576                 return true;
14577               case 2: //vdst
14578                 return false;
14579               default:
14580                 fatal("op idx %i out of bounds\n", opIdx);
14581                 return false;
14582             }
14583         } // isSrcOperand
14584
14585         bool
14586         isDstOperand(int opIdx) override
14587         {
14588             switch (opIdx) {
14589               case 0: //src_0
14590                 return false;
14591               case 1: //src_1
14592                 return false;
14593               case 2: //vdst
14594                 return true;
14595               default:
14596                 fatal("op idx %i out of bounds\n", opIdx);
14597                 return false;
14598             }
14599         } // isDstOperand
14600
14601         void execute(GPUDynInstPtr) override;
14602     }; // Inst_VOP2__V_MAX_F16
14603
14604     class Inst_VOP2__V_MIN_F16 : public Inst_VOP2
14605     {
14606       public:
14607         Inst_VOP2__V_MIN_F16(InFmt_VOP2*);
14608         ~Inst_VOP2__V_MIN_F16();
14609
14610         int
14611         getNumOperands() override
14612         {
14613             return numDstRegOperands() + numSrcRegOperands();
14614         } // getNumOperands
14615
14616         int numDstRegOperands() override { return 1; }
14617         int numSrcRegOperands() override { return 2; }
14618
14619         int
14620         getOperandSize(int opIdx) override
14621         {
14622             switch (opIdx) {
14623               case 0: //src_0
14624                 return 2;
14625               case 1: //src_1
14626                 return 2;
14627               case 2: //vdst
14628                 return 2;
14629               default:
14630                 fatal("op idx %i out of bounds\n", opIdx);
14631                 return -1;
14632             }
14633         } // getOperandSize
14634
14635         bool
14636         isSrcOperand(int opIdx) override
14637         {
14638             switch (opIdx) {
14639               case 0: //src_0
14640                 return true;
14641               case 1: //src_1
14642                 return true;
14643               case 2: //vdst
14644                 return false;
14645               default:
14646                 fatal("op idx %i out of bounds\n", opIdx);
14647                 return false;
14648             }
14649         } // isSrcOperand
14650
14651         bool
14652         isDstOperand(int opIdx) override
14653         {
14654             switch (opIdx) {
14655               case 0: //src_0
14656                 return false;
14657               case 1: //src_1
14658                 return false;
14659               case 2: //vdst
14660                 return true;
14661               default:
14662                 fatal("op idx %i out of bounds\n", opIdx);
14663                 return false;
14664             }
14665         } // isDstOperand
14666
14667         void execute(GPUDynInstPtr) override;
14668     }; // Inst_VOP2__V_MIN_F16
14669
14670     class Inst_VOP2__V_MAX_U16 : public Inst_VOP2
14671     {
14672       public:
14673         Inst_VOP2__V_MAX_U16(InFmt_VOP2*);
14674         ~Inst_VOP2__V_MAX_U16();
14675
14676         int
14677         getNumOperands() override
14678         {
14679             return numDstRegOperands() + numSrcRegOperands();
14680         } // getNumOperands
14681
14682         int numDstRegOperands() override { return 1; }
14683         int numSrcRegOperands() override { return 2; }
14684
14685         int
14686         getOperandSize(int opIdx) override
14687         {
14688             switch (opIdx) {
14689               case 0: //src_0
14690                 return 2;
14691               case 1: //src_1
14692                 return 2;
14693               case 2: //vdst
14694                 return 2;
14695               default:
14696                 fatal("op idx %i out of bounds\n", opIdx);
14697                 return -1;
14698             }
14699         } // getOperandSize
14700
14701         bool
14702         isSrcOperand(int opIdx) override
14703         {
14704             switch (opIdx) {
14705               case 0: //src_0
14706                 return true;
14707               case 1: //src_1
14708                 return true;
14709               case 2: //vdst
14710                 return false;
14711               default:
14712                 fatal("op idx %i out of bounds\n", opIdx);
14713                 return false;
14714             }
14715         } // isSrcOperand
14716
14717         bool
14718         isDstOperand(int opIdx) override
14719         {
14720             switch (opIdx) {
14721               case 0: //src_0
14722                 return false;
14723               case 1: //src_1
14724                 return false;
14725               case 2: //vdst
14726                 return true;
14727               default:
14728                 fatal("op idx %i out of bounds\n", opIdx);
14729                 return false;
14730             }
14731         } // isDstOperand
14732
14733         void execute(GPUDynInstPtr) override;
14734     }; // Inst_VOP2__V_MAX_U16
14735
14736     class Inst_VOP2__V_MAX_I16 : public Inst_VOP2
14737     {
14738       public:
14739         Inst_VOP2__V_MAX_I16(InFmt_VOP2*);
14740         ~Inst_VOP2__V_MAX_I16();
14741
14742         int
14743         getNumOperands() override
14744         {
14745             return numDstRegOperands() + numSrcRegOperands();
14746         } // getNumOperands
14747
14748         int numDstRegOperands() override { return 1; }
14749         int numSrcRegOperands() override { return 2; }
14750
14751         int
14752         getOperandSize(int opIdx) override
14753         {
14754             switch (opIdx) {
14755               case 0: //src_0
14756                 return 2;
14757               case 1: //src_1
14758                 return 2;
14759               case 2: //vdst
14760                 return 2;
14761               default:
14762                 fatal("op idx %i out of bounds\n", opIdx);
14763                 return -1;
14764             }
14765         } // getOperandSize
14766
14767         bool
14768         isSrcOperand(int opIdx) override
14769         {
14770             switch (opIdx) {
14771               case 0: //src_0
14772                 return true;
14773               case 1: //src_1
14774                 return true;
14775               case 2: //vdst
14776                 return false;
14777               default:
14778                 fatal("op idx %i out of bounds\n", opIdx);
14779                 return false;
14780             }
14781         } // isSrcOperand
14782
14783         bool
14784         isDstOperand(int opIdx) override
14785         {
14786             switch (opIdx) {
14787               case 0: //src_0
14788                 return false;
14789               case 1: //src_1
14790                 return false;
14791               case 2: //vdst
14792                 return true;
14793               default:
14794                 fatal("op idx %i out of bounds\n", opIdx);
14795                 return false;
14796             }
14797         } // isDstOperand
14798
14799         void execute(GPUDynInstPtr) override;
14800     }; // Inst_VOP2__V_MAX_I16
14801
14802     class Inst_VOP2__V_MIN_U16 : public Inst_VOP2
14803     {
14804       public:
14805         Inst_VOP2__V_MIN_U16(InFmt_VOP2*);
14806         ~Inst_VOP2__V_MIN_U16();
14807
14808         int
14809         getNumOperands() override
14810         {
14811             return numDstRegOperands() + numSrcRegOperands();
14812         } // getNumOperands
14813
14814         int numDstRegOperands() override { return 1; }
14815         int numSrcRegOperands() override { return 2; }
14816
14817         int
14818         getOperandSize(int opIdx) override
14819         {
14820             switch (opIdx) {
14821               case 0: //src_0
14822                 return 2;
14823               case 1: //src_1
14824                 return 2;
14825               case 2: //vdst
14826                 return 2;
14827               default:
14828                 fatal("op idx %i out of bounds\n", opIdx);
14829                 return -1;
14830             }
14831         } // getOperandSize
14832
14833         bool
14834         isSrcOperand(int opIdx) override
14835         {
14836             switch (opIdx) {
14837               case 0: //src_0
14838                 return true;
14839               case 1: //src_1
14840                 return true;
14841               case 2: //vdst
14842                 return false;
14843               default:
14844                 fatal("op idx %i out of bounds\n", opIdx);
14845                 return false;
14846             }
14847         } // isSrcOperand
14848
14849         bool
14850         isDstOperand(int opIdx) override
14851         {
14852             switch (opIdx) {
14853               case 0: //src_0
14854                 return false;
14855               case 1: //src_1
14856                 return false;
14857               case 2: //vdst
14858                 return true;
14859               default:
14860                 fatal("op idx %i out of bounds\n", opIdx);
14861                 return false;
14862             }
14863         } // isDstOperand
14864
14865         void execute(GPUDynInstPtr) override;
14866     }; // Inst_VOP2__V_MIN_U16
14867
14868     class Inst_VOP2__V_MIN_I16 : public Inst_VOP2
14869     {
14870       public:
14871         Inst_VOP2__V_MIN_I16(InFmt_VOP2*);
14872         ~Inst_VOP2__V_MIN_I16();
14873
14874         int
14875         getNumOperands() override
14876         {
14877             return numDstRegOperands() + numSrcRegOperands();
14878         } // getNumOperands
14879
14880         int numDstRegOperands() override { return 1; }
14881         int numSrcRegOperands() override { return 2; }
14882
14883         int
14884         getOperandSize(int opIdx) override
14885         {
14886             switch (opIdx) {
14887               case 0: //src_0
14888                 return 2;
14889               case 1: //src_1
14890                 return 2;
14891               case 2: //vdst
14892                 return 2;
14893               default:
14894                 fatal("op idx %i out of bounds\n", opIdx);
14895                 return -1;
14896             }
14897         } // getOperandSize
14898
14899         bool
14900         isSrcOperand(int opIdx) override
14901         {
14902             switch (opIdx) {
14903               case 0: //src_0
14904                 return true;
14905               case 1: //src_1
14906                 return true;
14907               case 2: //vdst
14908                 return false;
14909               default:
14910                 fatal("op idx %i out of bounds\n", opIdx);
14911                 return false;
14912             }
14913         } // isSrcOperand
14914
14915         bool
14916         isDstOperand(int opIdx) override
14917         {
14918             switch (opIdx) {
14919               case 0: //src_0
14920                 return false;
14921               case 1: //src_1
14922                 return false;
14923               case 2: //vdst
14924                 return true;
14925               default:
14926                 fatal("op idx %i out of bounds\n", opIdx);
14927                 return false;
14928             }
14929         } // isDstOperand
14930
14931         void execute(GPUDynInstPtr) override;
14932     }; // Inst_VOP2__V_MIN_I16
14933
14934     class Inst_VOP2__V_LDEXP_F16 : public Inst_VOP2
14935     {
14936       public:
14937         Inst_VOP2__V_LDEXP_F16(InFmt_VOP2*);
14938         ~Inst_VOP2__V_LDEXP_F16();
14939
14940         int
14941         getNumOperands() override
14942         {
14943             return numDstRegOperands() + numSrcRegOperands();
14944         } // getNumOperands
14945
14946         int numDstRegOperands() override { return 1; }
14947         int numSrcRegOperands() override { return 2; }
14948
14949         int
14950         getOperandSize(int opIdx) override
14951         {
14952             switch (opIdx) {
14953               case 0: //src_0
14954                 return 2;
14955               case 1: //src_1
14956                 return 2;
14957               case 2: //vdst
14958                 return 2;
14959               default:
14960                 fatal("op idx %i out of bounds\n", opIdx);
14961                 return -1;
14962             }
14963         } // getOperandSize
14964
14965         bool
14966         isSrcOperand(int opIdx) override
14967         {
14968             switch (opIdx) {
14969               case 0: //src_0
14970                 return true;
14971               case 1: //src_1
14972                 return true;
14973               case 2: //vdst
14974                 return false;
14975               default:
14976                 fatal("op idx %i out of bounds\n", opIdx);
14977                 return false;
14978             }
14979         } // isSrcOperand
14980
14981         bool
14982         isDstOperand(int opIdx) override
14983         {
14984             switch (opIdx) {
14985               case 0: //src_0
14986                 return false;
14987               case 1: //src_1
14988                 return false;
14989               case 2: //vdst
14990                 return true;
14991               default:
14992                 fatal("op idx %i out of bounds\n", opIdx);
14993                 return false;
14994             }
14995         } // isDstOperand
14996
14997         void execute(GPUDynInstPtr) override;
14998     }; // Inst_VOP2__V_LDEXP_F16
14999
15000     class Inst_VOP1__V_NOP : public Inst_VOP1
15001     {
15002       public:
15003         Inst_VOP1__V_NOP(InFmt_VOP1*);
15004         ~Inst_VOP1__V_NOP();
15005
15006         int
15007         getNumOperands() override
15008         {
15009             return numDstRegOperands() + numSrcRegOperands();
15010         } // getNumOperands
15011
15012         int numDstRegOperands() override { return 0; }
15013         int numSrcRegOperands() override { return 0; }
15014
15015         int
15016         getOperandSize(int opIdx) override
15017         {
15018             switch (opIdx) {
15019               default:
15020                 fatal("op idx %i out of bounds\n", opIdx);
15021                 return -1;
15022             }
15023         } // getOperandSize
15024
15025         bool
15026         isSrcOperand(int opIdx) override
15027         {
15028             switch (opIdx) {
15029               default:
15030                 fatal("op idx %i out of bounds\n", opIdx);
15031                 return false;
15032             }
15033         } // isSrcOperand
15034
15035         bool
15036         isDstOperand(int opIdx) override
15037         {
15038             switch (opIdx) {
15039               default:
15040                 fatal("op idx %i out of bounds\n", opIdx);
15041                 return false;
15042             }
15043         } // isDstOperand
15044
15045         void execute(GPUDynInstPtr) override;
15046     }; // Inst_VOP1__V_NOP
15047
15048     class Inst_VOP1__V_MOV_B32 : public Inst_VOP1
15049     {
15050       public:
15051         Inst_VOP1__V_MOV_B32(InFmt_VOP1*);
15052         ~Inst_VOP1__V_MOV_B32();
15053
15054         int
15055         getNumOperands() override
15056         {
15057             return numDstRegOperands() + numSrcRegOperands();
15058         } // getNumOperands
15059
15060         int numDstRegOperands() override { return 1; }
15061         int numSrcRegOperands() override { return 1; }
15062
15063         int
15064         getOperandSize(int opIdx) override
15065         {
15066             switch (opIdx) {
15067               case 0: //src
15068                 return 4;
15069               case 1: //vdst
15070                 return 4;
15071               default:
15072                 fatal("op idx %i out of bounds\n", opIdx);
15073                 return -1;
15074             }
15075         } // getOperandSize
15076
15077         bool
15078         isSrcOperand(int opIdx) override
15079         {
15080             switch (opIdx) {
15081               case 0: //src
15082                 return true;
15083               case 1: //vdst
15084                 return false;
15085               default:
15086                 fatal("op idx %i out of bounds\n", opIdx);
15087                 return false;
15088             }
15089         } // isSrcOperand
15090
15091         bool
15092         isDstOperand(int opIdx) override
15093         {
15094             switch (opIdx) {
15095               case 0: //src
15096                 return false;
15097               case 1: //vdst
15098                 return true;
15099               default:
15100                 fatal("op idx %i out of bounds\n", opIdx);
15101                 return false;
15102             }
15103         } // isDstOperand
15104
15105         void execute(GPUDynInstPtr) override;
15106     }; // Inst_VOP1__V_MOV_B32
15107
15108     class Inst_VOP1__V_READFIRSTLANE_B32 : public Inst_VOP1
15109     {
15110       public:
15111         Inst_VOP1__V_READFIRSTLANE_B32(InFmt_VOP1*);
15112         ~Inst_VOP1__V_READFIRSTLANE_B32();
15113
15114         int
15115         getNumOperands() override
15116         {
15117             return numDstRegOperands() + numSrcRegOperands();
15118         } // getNumOperands
15119
15120         int numDstRegOperands() override { return 1; }
15121         int numSrcRegOperands() override { return 1; }
15122
15123         int
15124         getOperandSize(int opIdx) override
15125         {
15126             switch (opIdx) {
15127               case 0: //vsrc
15128                 return 4;
15129               case 1: //sdst
15130                 return 4;
15131               default:
15132                 fatal("op idx %i out of bounds\n", opIdx);
15133                 return -1;
15134             }
15135         } // getOperandSize
15136
15137         bool
15138         isSrcOperand(int opIdx) override
15139         {
15140             switch (opIdx) {
15141               case 0: //vsrc
15142                 return true;
15143               case 1: //sdst
15144                 return false;
15145               default:
15146                 fatal("op idx %i out of bounds\n", opIdx);
15147                 return false;
15148             }
15149         } // isSrcOperand
15150
15151         bool
15152         isDstOperand(int opIdx) override
15153         {
15154             switch (opIdx) {
15155               case 0: //vsrc
15156                 return false;
15157               case 1: //sdst
15158                 return true;
15159               default:
15160                 fatal("op idx %i out of bounds\n", opIdx);
15161                 return false;
15162             }
15163         } // isDstOperand
15164
15165         void execute(GPUDynInstPtr) override;
15166     }; // Inst_VOP1__V_READFIRSTLANE_B32
15167
15168     class Inst_VOP1__V_CVT_I32_F64 : public Inst_VOP1
15169     {
15170       public:
15171         Inst_VOP1__V_CVT_I32_F64(InFmt_VOP1*);
15172         ~Inst_VOP1__V_CVT_I32_F64();
15173
15174         int
15175         getNumOperands() override
15176         {
15177             return numDstRegOperands() + numSrcRegOperands();
15178         } // getNumOperands
15179
15180         int numDstRegOperands() override { return 1; }
15181         int numSrcRegOperands() override { return 1; }
15182
15183         int
15184         getOperandSize(int opIdx) override
15185         {
15186             switch (opIdx) {
15187               case 0: //src
15188                 return 8;
15189               case 1: //vdst
15190                 return 4;
15191               default:
15192                 fatal("op idx %i out of bounds\n", opIdx);
15193                 return -1;
15194             }
15195         } // getOperandSize
15196
15197         bool
15198         isSrcOperand(int opIdx) override
15199         {
15200             switch (opIdx) {
15201               case 0: //src
15202                 return true;
15203               case 1: //vdst
15204                 return false;
15205               default:
15206                 fatal("op idx %i out of bounds\n", opIdx);
15207                 return false;
15208             }
15209         } // isSrcOperand
15210
15211         bool
15212         isDstOperand(int opIdx) override
15213         {
15214             switch (opIdx) {
15215               case 0: //src
15216                 return false;
15217               case 1: //vdst
15218                 return true;
15219               default:
15220                 fatal("op idx %i out of bounds\n", opIdx);
15221                 return false;
15222             }
15223         } // isDstOperand
15224
15225         void execute(GPUDynInstPtr) override;
15226     }; // Inst_VOP1__V_CVT_I32_F64
15227
15228     class Inst_VOP1__V_CVT_F64_I32 : public Inst_VOP1
15229     {
15230       public:
15231         Inst_VOP1__V_CVT_F64_I32(InFmt_VOP1*);
15232         ~Inst_VOP1__V_CVT_F64_I32();
15233
15234         int
15235         getNumOperands() override
15236         {
15237             return numDstRegOperands() + numSrcRegOperands();
15238         } // getNumOperands
15239
15240         int numDstRegOperands() override { return 1; }
15241         int numSrcRegOperands() override { return 1; }
15242
15243         int
15244         getOperandSize(int opIdx) override
15245         {
15246             switch (opIdx) {
15247               case 0: //src
15248                 return 4;
15249               case 1: //vdst
15250                 return 8;
15251               default:
15252                 fatal("op idx %i out of bounds\n", opIdx);
15253                 return -1;
15254             }
15255         } // getOperandSize
15256
15257         bool
15258         isSrcOperand(int opIdx) override
15259         {
15260             switch (opIdx) {
15261               case 0: //src
15262                 return true;
15263               case 1: //vdst
15264                 return false;
15265               default:
15266                 fatal("op idx %i out of bounds\n", opIdx);
15267                 return false;
15268             }
15269         } // isSrcOperand
15270
15271         bool
15272         isDstOperand(int opIdx) override
15273         {
15274             switch (opIdx) {
15275               case 0: //src
15276                 return false;
15277               case 1: //vdst
15278                 return true;
15279               default:
15280                 fatal("op idx %i out of bounds\n", opIdx);
15281                 return false;
15282             }
15283         } // isDstOperand
15284
15285         void execute(GPUDynInstPtr) override;
15286     }; // Inst_VOP1__V_CVT_F64_I32
15287
15288     class Inst_VOP1__V_CVT_F32_I32 : public Inst_VOP1
15289     {
15290       public:
15291         Inst_VOP1__V_CVT_F32_I32(InFmt_VOP1*);
15292         ~Inst_VOP1__V_CVT_F32_I32();
15293
15294         int
15295         getNumOperands() override
15296         {
15297             return numDstRegOperands() + numSrcRegOperands();
15298         } // getNumOperands
15299
15300         int numDstRegOperands() override { return 1; }
15301         int numSrcRegOperands() override { return 1; }
15302
15303         int
15304         getOperandSize(int opIdx) override
15305         {
15306             switch (opIdx) {
15307               case 0: //src
15308                 return 4;
15309               case 1: //vdst
15310                 return 4;
15311               default:
15312                 fatal("op idx %i out of bounds\n", opIdx);
15313                 return -1;
15314             }
15315         } // getOperandSize
15316
15317         bool
15318         isSrcOperand(int opIdx) override
15319         {
15320             switch (opIdx) {
15321               case 0: //src
15322                 return true;
15323               case 1: //vdst
15324                 return false;
15325               default:
15326                 fatal("op idx %i out of bounds\n", opIdx);
15327                 return false;
15328             }
15329         } // isSrcOperand
15330
15331         bool
15332         isDstOperand(int opIdx) override
15333         {
15334             switch (opIdx) {
15335               case 0: //src
15336                 return false;
15337               case 1: //vdst
15338                 return true;
15339               default:
15340                 fatal("op idx %i out of bounds\n", opIdx);
15341                 return false;
15342             }
15343         } // isDstOperand
15344
15345         void execute(GPUDynInstPtr) override;
15346     }; // Inst_VOP1__V_CVT_F32_I32
15347
15348     class Inst_VOP1__V_CVT_F32_U32 : public Inst_VOP1
15349     {
15350       public:
15351         Inst_VOP1__V_CVT_F32_U32(InFmt_VOP1*);
15352         ~Inst_VOP1__V_CVT_F32_U32();
15353
15354         int
15355         getNumOperands() override
15356         {
15357             return numDstRegOperands() + numSrcRegOperands();
15358         } // getNumOperands
15359
15360         int numDstRegOperands() override { return 1; }
15361         int numSrcRegOperands() override { return 1; }
15362
15363         int
15364         getOperandSize(int opIdx) override
15365         {
15366             switch (opIdx) {
15367               case 0: //src
15368                 return 4;
15369               case 1: //vdst
15370                 return 4;
15371               default:
15372                 fatal("op idx %i out of bounds\n", opIdx);
15373                 return -1;
15374             }
15375         } // getOperandSize
15376
15377         bool
15378         isSrcOperand(int opIdx) override
15379         {
15380             switch (opIdx) {
15381               case 0: //src
15382                 return true;
15383               case 1: //vdst
15384                 return false;
15385               default:
15386                 fatal("op idx %i out of bounds\n", opIdx);
15387                 return false;
15388             }
15389         } // isSrcOperand
15390
15391         bool
15392         isDstOperand(int opIdx) override
15393         {
15394             switch (opIdx) {
15395               case 0: //src
15396                 return false;
15397               case 1: //vdst
15398                 return true;
15399               default:
15400                 fatal("op idx %i out of bounds\n", opIdx);
15401                 return false;
15402             }
15403         } // isDstOperand
15404
15405         void execute(GPUDynInstPtr) override;
15406     }; // Inst_VOP1__V_CVT_F32_U32
15407
15408     class Inst_VOP1__V_CVT_U32_F32 : public Inst_VOP1
15409     {
15410       public:
15411         Inst_VOP1__V_CVT_U32_F32(InFmt_VOP1*);
15412         ~Inst_VOP1__V_CVT_U32_F32();
15413
15414         int
15415         getNumOperands() override
15416         {
15417             return numDstRegOperands() + numSrcRegOperands();
15418         } // getNumOperands
15419
15420         int numDstRegOperands() override { return 1; }
15421         int numSrcRegOperands() override { return 1; }
15422
15423         int
15424         getOperandSize(int opIdx) override
15425         {
15426             switch (opIdx) {
15427               case 0: //src
15428                 return 4;
15429               case 1: //vdst
15430                 return 4;
15431               default:
15432                 fatal("op idx %i out of bounds\n", opIdx);
15433                 return -1;
15434             }
15435         } // getOperandSize
15436
15437         bool
15438         isSrcOperand(int opIdx) override
15439         {
15440             switch (opIdx) {
15441               case 0: //src
15442                 return true;
15443               case 1: //vdst
15444                 return false;
15445               default:
15446                 fatal("op idx %i out of bounds\n", opIdx);
15447                 return false;
15448             }
15449         } // isSrcOperand
15450
15451         bool
15452         isDstOperand(int opIdx) override
15453         {
15454             switch (opIdx) {
15455               case 0: //src
15456                 return false;
15457               case 1: //vdst
15458                 return true;
15459               default:
15460                 fatal("op idx %i out of bounds\n", opIdx);
15461                 return false;
15462             }
15463         } // isDstOperand
15464
15465         void execute(GPUDynInstPtr) override;
15466     }; // Inst_VOP1__V_CVT_U32_F32
15467
15468     class Inst_VOP1__V_CVT_I32_F32 : public Inst_VOP1
15469     {
15470       public:
15471         Inst_VOP1__V_CVT_I32_F32(InFmt_VOP1*);
15472         ~Inst_VOP1__V_CVT_I32_F32();
15473
15474         int
15475         getNumOperands() override
15476         {
15477             return numDstRegOperands() + numSrcRegOperands();
15478         } // getNumOperands
15479
15480         int numDstRegOperands() override { return 1; }
15481         int numSrcRegOperands() override { return 1; }
15482
15483         int
15484         getOperandSize(int opIdx) override
15485         {
15486             switch (opIdx) {
15487               case 0: //src
15488                 return 4;
15489               case 1: //vdst
15490                 return 4;
15491               default:
15492                 fatal("op idx %i out of bounds\n", opIdx);
15493                 return -1;
15494             }
15495         } // getOperandSize
15496
15497         bool
15498         isSrcOperand(int opIdx) override
15499         {
15500             switch (opIdx) {
15501               case 0: //src
15502                 return true;
15503               case 1: //vdst
15504                 return false;
15505               default:
15506                 fatal("op idx %i out of bounds\n", opIdx);
15507                 return false;
15508             }
15509         } // isSrcOperand
15510
15511         bool
15512         isDstOperand(int opIdx) override
15513         {
15514             switch (opIdx) {
15515               case 0: //src
15516                 return false;
15517               case 1: //vdst
15518                 return true;
15519               default:
15520                 fatal("op idx %i out of bounds\n", opIdx);
15521                 return false;
15522             }
15523         } // isDstOperand
15524
15525         void execute(GPUDynInstPtr) override;
15526     }; // Inst_VOP1__V_CVT_I32_F32
15527
15528     class Inst_VOP1__V_MOV_FED_B32 : public Inst_VOP1
15529     {
15530       public:
15531         Inst_VOP1__V_MOV_FED_B32(InFmt_VOP1*);
15532         ~Inst_VOP1__V_MOV_FED_B32();
15533
15534         int
15535         getNumOperands() override
15536         {
15537             return numDstRegOperands() + numSrcRegOperands();
15538         } // getNumOperands
15539
15540         int numDstRegOperands() override { return 1; }
15541         int numSrcRegOperands() override { return 1; }
15542
15543         int
15544         getOperandSize(int opIdx) override
15545         {
15546             switch (opIdx) {
15547               case 0: //src
15548                 return 4;
15549               case 1: //vdst
15550                 return 4;
15551               default:
15552                 fatal("op idx %i out of bounds\n", opIdx);
15553                 return -1;
15554             }
15555         } // getOperandSize
15556
15557         bool
15558         isSrcOperand(int opIdx) override
15559         {
15560             switch (opIdx) {
15561               case 0: //src
15562                 return true;
15563               case 1: //vdst
15564                 return false;
15565               default:
15566                 fatal("op idx %i out of bounds\n", opIdx);
15567                 return false;
15568             }
15569         } // isSrcOperand
15570
15571         bool
15572         isDstOperand(int opIdx) override
15573         {
15574             switch (opIdx) {
15575               case 0: //src
15576                 return false;
15577               case 1: //vdst
15578                 return true;
15579               default:
15580                 fatal("op idx %i out of bounds\n", opIdx);
15581                 return false;
15582             }
15583         } // isDstOperand
15584
15585         void execute(GPUDynInstPtr) override;
15586     }; // Inst_VOP1__V_MOV_FED_B32
15587
15588     class Inst_VOP1__V_CVT_F16_F32 : public Inst_VOP1
15589     {
15590       public:
15591         Inst_VOP1__V_CVT_F16_F32(InFmt_VOP1*);
15592         ~Inst_VOP1__V_CVT_F16_F32();
15593
15594         int
15595         getNumOperands() override
15596         {
15597             return numDstRegOperands() + numSrcRegOperands();
15598         } // getNumOperands
15599
15600         int numDstRegOperands() override { return 1; }
15601         int numSrcRegOperands() override { return 1; }
15602
15603         int
15604         getOperandSize(int opIdx) override
15605         {
15606             switch (opIdx) {
15607               case 0: //src
15608                 return 4;
15609               case 1: //vdst
15610                 return 2;
15611               default:
15612                 fatal("op idx %i out of bounds\n", opIdx);
15613                 return -1;
15614             }
15615         } // getOperandSize
15616
15617         bool
15618         isSrcOperand(int opIdx) override
15619         {
15620             switch (opIdx) {
15621               case 0: //src
15622                 return true;
15623               case 1: //vdst
15624                 return false;
15625               default:
15626                 fatal("op idx %i out of bounds\n", opIdx);
15627                 return false;
15628             }
15629         } // isSrcOperand
15630
15631         bool
15632         isDstOperand(int opIdx) override
15633         {
15634             switch (opIdx) {
15635               case 0: //src
15636                 return false;
15637               case 1: //vdst
15638                 return true;
15639               default:
15640                 fatal("op idx %i out of bounds\n", opIdx);
15641                 return false;
15642             }
15643         } // isDstOperand
15644
15645         void execute(GPUDynInstPtr) override;
15646     }; // Inst_VOP1__V_CVT_F16_F32
15647
15648     class Inst_VOP1__V_CVT_F32_F16 : public Inst_VOP1
15649     {
15650       public:
15651         Inst_VOP1__V_CVT_F32_F16(InFmt_VOP1*);
15652         ~Inst_VOP1__V_CVT_F32_F16();
15653
15654         int
15655         getNumOperands() override
15656         {
15657             return numDstRegOperands() + numSrcRegOperands();
15658         } // getNumOperands
15659
15660         int numDstRegOperands() override { return 1; }
15661         int numSrcRegOperands() override { return 1; }
15662
15663         int
15664         getOperandSize(int opIdx) override
15665         {
15666             switch (opIdx) {
15667               case 0: //src
15668                 return 2;
15669               case 1: //vdst
15670                 return 4;
15671               default:
15672                 fatal("op idx %i out of bounds\n", opIdx);
15673                 return -1;
15674             }
15675         } // getOperandSize
15676
15677         bool
15678         isSrcOperand(int opIdx) override
15679         {
15680             switch (opIdx) {
15681               case 0: //src
15682                 return true;
15683               case 1: //vdst
15684                 return false;
15685               default:
15686                 fatal("op idx %i out of bounds\n", opIdx);
15687                 return false;
15688             }
15689         } // isSrcOperand
15690
15691         bool
15692         isDstOperand(int opIdx) override
15693         {
15694             switch (opIdx) {
15695               case 0: //src
15696                 return false;
15697               case 1: //vdst
15698                 return true;
15699               default:
15700                 fatal("op idx %i out of bounds\n", opIdx);
15701                 return false;
15702             }
15703         } // isDstOperand
15704
15705         void execute(GPUDynInstPtr) override;
15706     }; // Inst_VOP1__V_CVT_F32_F16
15707
15708     class Inst_VOP1__V_CVT_RPI_I32_F32 : public Inst_VOP1
15709     {
15710       public:
15711         Inst_VOP1__V_CVT_RPI_I32_F32(InFmt_VOP1*);
15712         ~Inst_VOP1__V_CVT_RPI_I32_F32();
15713
15714         int
15715         getNumOperands() override
15716         {
15717             return numDstRegOperands() + numSrcRegOperands();
15718         } // getNumOperands
15719
15720         int numDstRegOperands() override { return 1; }
15721         int numSrcRegOperands() override { return 1; }
15722
15723         int
15724         getOperandSize(int opIdx) override
15725         {
15726             switch (opIdx) {
15727               case 0: //src
15728                 return 4;
15729               case 1: //vdst
15730                 return 4;
15731               default:
15732                 fatal("op idx %i out of bounds\n", opIdx);
15733                 return -1;
15734             }
15735         } // getOperandSize
15736
15737         bool
15738         isSrcOperand(int opIdx) override
15739         {
15740             switch (opIdx) {
15741               case 0: //src
15742                 return true;
15743               case 1: //vdst
15744                 return false;
15745               default:
15746                 fatal("op idx %i out of bounds\n", opIdx);
15747                 return false;
15748             }
15749         } // isSrcOperand
15750
15751         bool
15752         isDstOperand(int opIdx) override
15753         {
15754             switch (opIdx) {
15755               case 0: //src
15756                 return false;
15757               case 1: //vdst
15758                 return true;
15759               default:
15760                 fatal("op idx %i out of bounds\n", opIdx);
15761                 return false;
15762             }
15763         } // isDstOperand
15764
15765         void execute(GPUDynInstPtr) override;
15766     }; // Inst_VOP1__V_CVT_RPI_I32_F32
15767
15768     class Inst_VOP1__V_CVT_FLR_I32_F32 : public Inst_VOP1
15769     {
15770       public:
15771         Inst_VOP1__V_CVT_FLR_I32_F32(InFmt_VOP1*);
15772         ~Inst_VOP1__V_CVT_FLR_I32_F32();
15773
15774         int
15775         getNumOperands() override
15776         {
15777             return numDstRegOperands() + numSrcRegOperands();
15778         } // getNumOperands
15779
15780         int numDstRegOperands() override { return 1; }
15781         int numSrcRegOperands() override { return 1; }
15782
15783         int
15784         getOperandSize(int opIdx) override
15785         {
15786             switch (opIdx) {
15787               case 0: //src
15788                 return 4;
15789               case 1: //vdst
15790                 return 4;
15791               default:
15792                 fatal("op idx %i out of bounds\n", opIdx);
15793                 return -1;
15794             }
15795         } // getOperandSize
15796
15797         bool
15798         isSrcOperand(int opIdx) override
15799         {
15800             switch (opIdx) {
15801               case 0: //src
15802                 return true;
15803               case 1: //vdst
15804                 return false;
15805               default:
15806                 fatal("op idx %i out of bounds\n", opIdx);
15807                 return false;
15808             }
15809         } // isSrcOperand
15810
15811         bool
15812         isDstOperand(int opIdx) override
15813         {
15814             switch (opIdx) {
15815               case 0: //src
15816                 return false;
15817               case 1: //vdst
15818                 return true;
15819               default:
15820                 fatal("op idx %i out of bounds\n", opIdx);
15821                 return false;
15822             }
15823         } // isDstOperand
15824
15825         void execute(GPUDynInstPtr) override;
15826     }; // Inst_VOP1__V_CVT_FLR_I32_F32
15827
15828     class Inst_VOP1__V_CVT_OFF_F32_I4 : public Inst_VOP1
15829     {
15830       public:
15831         Inst_VOP1__V_CVT_OFF_F32_I4(InFmt_VOP1*);
15832         ~Inst_VOP1__V_CVT_OFF_F32_I4();
15833
15834         int
15835         getNumOperands() override
15836         {
15837             return numDstRegOperands() + numSrcRegOperands();
15838         } // getNumOperands
15839
15840         int numDstRegOperands() override { return 1; }
15841         int numSrcRegOperands() override { return 1; }
15842
15843         int
15844         getOperandSize(int opIdx) override
15845         {
15846             switch (opIdx) {
15847               case 0: //src
15848                 return 4;
15849               case 1: //vdst
15850                 return 4;
15851               default:
15852                 fatal("op idx %i out of bounds\n", opIdx);
15853                 return -1;
15854             }
15855         } // getOperandSize
15856
15857         bool
15858         isSrcOperand(int opIdx) override
15859         {
15860             switch (opIdx) {
15861               case 0: //src
15862                 return true;
15863               case 1: //vdst
15864                 return false;
15865               default:
15866                 fatal("op idx %i out of bounds\n", opIdx);
15867                 return false;
15868             }
15869         } // isSrcOperand
15870
15871         bool
15872         isDstOperand(int opIdx) override
15873         {
15874             switch (opIdx) {
15875               case 0: //src
15876                 return false;
15877               case 1: //vdst
15878                 return true;
15879               default:
15880                 fatal("op idx %i out of bounds\n", opIdx);
15881                 return false;
15882             }
15883         } // isDstOperand
15884
15885         void execute(GPUDynInstPtr) override;
15886     }; // Inst_VOP1__V_CVT_OFF_F32_I4
15887
15888     class Inst_VOP1__V_CVT_F32_F64 : public Inst_VOP1
15889     {
15890       public:
15891         Inst_VOP1__V_CVT_F32_F64(InFmt_VOP1*);
15892         ~Inst_VOP1__V_CVT_F32_F64();
15893
15894         int
15895         getNumOperands() override
15896         {
15897             return numDstRegOperands() + numSrcRegOperands();
15898         } // getNumOperands
15899
15900         int numDstRegOperands() override { return 1; }
15901         int numSrcRegOperands() override { return 1; }
15902
15903         int
15904         getOperandSize(int opIdx) override
15905         {
15906             switch (opIdx) {
15907               case 0: //src
15908                 return 8;
15909               case 1: //vdst
15910                 return 4;
15911               default:
15912                 fatal("op idx %i out of bounds\n", opIdx);
15913                 return -1;
15914             }
15915         } // getOperandSize
15916
15917         bool
15918         isSrcOperand(int opIdx) override
15919         {
15920             switch (opIdx) {
15921               case 0: //src
15922                 return true;
15923               case 1: //vdst
15924                 return false;
15925               default:
15926                 fatal("op idx %i out of bounds\n", opIdx);
15927                 return false;
15928             }
15929         } // isSrcOperand
15930
15931         bool
15932         isDstOperand(int opIdx) override
15933         {
15934             switch (opIdx) {
15935               case 0: //src
15936                 return false;
15937               case 1: //vdst
15938                 return true;
15939               default:
15940                 fatal("op idx %i out of bounds\n", opIdx);
15941                 return false;
15942             }
15943         } // isDstOperand
15944
15945         void execute(GPUDynInstPtr) override;
15946     }; // Inst_VOP1__V_CVT_F32_F64
15947
15948     class Inst_VOP1__V_CVT_F64_F32 : public Inst_VOP1
15949     {
15950       public:
15951         Inst_VOP1__V_CVT_F64_F32(InFmt_VOP1*);
15952         ~Inst_VOP1__V_CVT_F64_F32();
15953
15954         int
15955         getNumOperands() override
15956         {
15957             return numDstRegOperands() + numSrcRegOperands();
15958         } // getNumOperands
15959
15960         int numDstRegOperands() override { return 1; }
15961         int numSrcRegOperands() override { return 1; }
15962
15963         int
15964         getOperandSize(int opIdx) override
15965         {
15966             switch (opIdx) {
15967               case 0: //src
15968                 return 4;
15969               case 1: //vdst
15970                 return 8;
15971               default:
15972                 fatal("op idx %i out of bounds\n", opIdx);
15973                 return -1;
15974             }
15975         } // getOperandSize
15976
15977         bool
15978         isSrcOperand(int opIdx) override
15979         {
15980             switch (opIdx) {
15981               case 0: //src
15982                 return true;
15983               case 1: //vdst
15984                 return false;
15985               default:
15986                 fatal("op idx %i out of bounds\n", opIdx);
15987                 return false;
15988             }
15989         } // isSrcOperand
15990
15991         bool
15992         isDstOperand(int opIdx) override
15993         {
15994             switch (opIdx) {
15995               case 0: //src
15996                 return false;
15997               case 1: //vdst
15998                 return true;
15999               default:
16000                 fatal("op idx %i out of bounds\n", opIdx);
16001                 return false;
16002             }
16003         } // isDstOperand
16004
16005         void execute(GPUDynInstPtr) override;
16006     }; // Inst_VOP1__V_CVT_F64_F32
16007
16008     class Inst_VOP1__V_CVT_F32_UBYTE0 : public Inst_VOP1
16009     {
16010       public:
16011         Inst_VOP1__V_CVT_F32_UBYTE0(InFmt_VOP1*);
16012         ~Inst_VOP1__V_CVT_F32_UBYTE0();
16013
16014         int
16015         getNumOperands() override
16016         {
16017             return numDstRegOperands() + numSrcRegOperands();
16018         } // getNumOperands
16019
16020         int numDstRegOperands() override { return 1; }
16021         int numSrcRegOperands() override { return 1; }
16022
16023         int
16024         getOperandSize(int opIdx) override
16025         {
16026             switch (opIdx) {
16027               case 0: //src
16028                 return 4;
16029               case 1: //vdst
16030                 return 4;
16031               default:
16032                 fatal("op idx %i out of bounds\n", opIdx);
16033                 return -1;
16034             }
16035         } // getOperandSize
16036
16037         bool
16038         isSrcOperand(int opIdx) override
16039         {
16040             switch (opIdx) {
16041               case 0: //src
16042                 return true;
16043               case 1: //vdst
16044                 return false;
16045               default:
16046                 fatal("op idx %i out of bounds\n", opIdx);
16047                 return false;
16048             }
16049         } // isSrcOperand
16050
16051         bool
16052         isDstOperand(int opIdx) override
16053         {
16054             switch (opIdx) {
16055               case 0: //src
16056                 return false;
16057               case 1: //vdst
16058                 return true;
16059               default:
16060                 fatal("op idx %i out of bounds\n", opIdx);
16061                 return false;
16062             }
16063         } // isDstOperand
16064
16065         void execute(GPUDynInstPtr) override;
16066     }; // Inst_VOP1__V_CVT_F32_UBYTE0
16067
16068     class Inst_VOP1__V_CVT_F32_UBYTE1 : public Inst_VOP1
16069     {
16070       public:
16071         Inst_VOP1__V_CVT_F32_UBYTE1(InFmt_VOP1*);
16072         ~Inst_VOP1__V_CVT_F32_UBYTE1();
16073
16074         int
16075         getNumOperands() override
16076         {
16077             return numDstRegOperands() + numSrcRegOperands();
16078         } // getNumOperands
16079
16080         int numDstRegOperands() override { return 1; }
16081         int numSrcRegOperands() override { return 1; }
16082
16083         int
16084         getOperandSize(int opIdx) override
16085         {
16086             switch (opIdx) {
16087               case 0: //src
16088                 return 4;
16089               case 1: //vdst
16090                 return 4;
16091               default:
16092                 fatal("op idx %i out of bounds\n", opIdx);
16093                 return -1;
16094             }
16095         } // getOperandSize
16096
16097         bool
16098         isSrcOperand(int opIdx) override
16099         {
16100             switch (opIdx) {
16101               case 0: //src
16102                 return true;
16103               case 1: //vdst
16104                 return false;
16105               default:
16106                 fatal("op idx %i out of bounds\n", opIdx);
16107                 return false;
16108             }
16109         } // isSrcOperand
16110
16111         bool
16112         isDstOperand(int opIdx) override
16113         {
16114             switch (opIdx) {
16115               case 0: //src
16116                 return false;
16117               case 1: //vdst
16118                 return true;
16119               default:
16120                 fatal("op idx %i out of bounds\n", opIdx);
16121                 return false;
16122             }
16123         } // isDstOperand
16124
16125         void execute(GPUDynInstPtr) override;
16126     }; // Inst_VOP1__V_CVT_F32_UBYTE1
16127
16128     class Inst_VOP1__V_CVT_F32_UBYTE2 : public Inst_VOP1
16129     {
16130       public:
16131         Inst_VOP1__V_CVT_F32_UBYTE2(InFmt_VOP1*);
16132         ~Inst_VOP1__V_CVT_F32_UBYTE2();
16133
16134         int
16135         getNumOperands() override
16136         {
16137             return numDstRegOperands() + numSrcRegOperands();
16138         } // getNumOperands
16139
16140         int numDstRegOperands() override { return 1; }
16141         int numSrcRegOperands() override { return 1; }
16142
16143         int
16144         getOperandSize(int opIdx) override
16145         {
16146             switch (opIdx) {
16147               case 0: //src
16148                 return 4;
16149               case 1: //vdst
16150                 return 4;
16151               default:
16152                 fatal("op idx %i out of bounds\n", opIdx);
16153                 return -1;
16154             }
16155         } // getOperandSize
16156
16157         bool
16158         isSrcOperand(int opIdx) override
16159         {
16160             switch (opIdx) {
16161               case 0: //src
16162                 return true;
16163               case 1: //vdst
16164                 return false;
16165               default:
16166                 fatal("op idx %i out of bounds\n", opIdx);
16167                 return false;
16168             }
16169         } // isSrcOperand
16170
16171         bool
16172         isDstOperand(int opIdx) override
16173         {
16174             switch (opIdx) {
16175               case 0: //src
16176                 return false;
16177               case 1: //vdst
16178                 return true;
16179               default:
16180                 fatal("op idx %i out of bounds\n", opIdx);
16181                 return false;
16182             }
16183         } // isDstOperand
16184
16185         void execute(GPUDynInstPtr) override;
16186     }; // Inst_VOP1__V_CVT_F32_UBYTE2
16187
16188     class Inst_VOP1__V_CVT_F32_UBYTE3 : public Inst_VOP1
16189     {
16190       public:
16191         Inst_VOP1__V_CVT_F32_UBYTE3(InFmt_VOP1*);
16192         ~Inst_VOP1__V_CVT_F32_UBYTE3();
16193
16194         int
16195         getNumOperands() override
16196         {
16197             return numDstRegOperands() + numSrcRegOperands();
16198         } // getNumOperands
16199
16200         int numDstRegOperands() override { return 1; }
16201         int numSrcRegOperands() override { return 1; }
16202
16203         int
16204         getOperandSize(int opIdx) override
16205         {
16206             switch (opIdx) {
16207               case 0: //src
16208                 return 4;
16209               case 1: //vdst
16210                 return 4;
16211               default:
16212                 fatal("op idx %i out of bounds\n", opIdx);
16213                 return -1;
16214             }
16215         } // getOperandSize
16216
16217         bool
16218         isSrcOperand(int opIdx) override
16219         {
16220             switch (opIdx) {
16221               case 0: //src
16222                 return true;
16223               case 1: //vdst
16224                 return false;
16225               default:
16226                 fatal("op idx %i out of bounds\n", opIdx);
16227                 return false;
16228             }
16229         } // isSrcOperand
16230
16231         bool
16232         isDstOperand(int opIdx) override
16233         {
16234             switch (opIdx) {
16235               case 0: //src
16236                 return false;
16237               case 1: //vdst
16238                 return true;
16239               default:
16240                 fatal("op idx %i out of bounds\n", opIdx);
16241                 return false;
16242             }
16243         } // isDstOperand
16244
16245         void execute(GPUDynInstPtr) override;
16246     }; // Inst_VOP1__V_CVT_F32_UBYTE3
16247
16248     class Inst_VOP1__V_CVT_U32_F64 : public Inst_VOP1
16249     {
16250       public:
16251         Inst_VOP1__V_CVT_U32_F64(InFmt_VOP1*);
16252         ~Inst_VOP1__V_CVT_U32_F64();
16253
16254         int
16255         getNumOperands() override
16256         {
16257             return numDstRegOperands() + numSrcRegOperands();
16258         } // getNumOperands
16259
16260         int numDstRegOperands() override { return 1; }
16261         int numSrcRegOperands() override { return 1; }
16262
16263         int
16264         getOperandSize(int opIdx) override
16265         {
16266             switch (opIdx) {
16267               case 0: //src
16268                 return 8;
16269               case 1: //vdst
16270                 return 4;
16271               default:
16272                 fatal("op idx %i out of bounds\n", opIdx);
16273                 return -1;
16274             }
16275         } // getOperandSize
16276
16277         bool
16278         isSrcOperand(int opIdx) override
16279         {
16280             switch (opIdx) {
16281               case 0: //src
16282                 return true;
16283               case 1: //vdst
16284                 return false;
16285               default:
16286                 fatal("op idx %i out of bounds\n", opIdx);
16287                 return false;
16288             }
16289         } // isSrcOperand
16290
16291         bool
16292         isDstOperand(int opIdx) override
16293         {
16294             switch (opIdx) {
16295               case 0: //src
16296                 return false;
16297               case 1: //vdst
16298                 return true;
16299               default:
16300                 fatal("op idx %i out of bounds\n", opIdx);
16301                 return false;
16302             }
16303         } // isDstOperand
16304
16305         void execute(GPUDynInstPtr) override;
16306     }; // Inst_VOP1__V_CVT_U32_F64
16307
16308     class Inst_VOP1__V_CVT_F64_U32 : public Inst_VOP1
16309     {
16310       public:
16311         Inst_VOP1__V_CVT_F64_U32(InFmt_VOP1*);
16312         ~Inst_VOP1__V_CVT_F64_U32();
16313
16314         int
16315         getNumOperands() override
16316         {
16317             return numDstRegOperands() + numSrcRegOperands();
16318         } // getNumOperands
16319
16320         int numDstRegOperands() override { return 1; }
16321         int numSrcRegOperands() override { return 1; }
16322
16323         int
16324         getOperandSize(int opIdx) override
16325         {
16326             switch (opIdx) {
16327               case 0: //src
16328                 return 4;
16329               case 1: //vdst
16330                 return 8;
16331               default:
16332                 fatal("op idx %i out of bounds\n", opIdx);
16333                 return -1;
16334             }
16335         } // getOperandSize
16336
16337         bool
16338         isSrcOperand(int opIdx) override
16339         {
16340             switch (opIdx) {
16341               case 0: //src
16342                 return true;
16343               case 1: //vdst
16344                 return false;
16345               default:
16346                 fatal("op idx %i out of bounds\n", opIdx);
16347                 return false;
16348             }
16349         } // isSrcOperand
16350
16351         bool
16352         isDstOperand(int opIdx) override
16353         {
16354             switch (opIdx) {
16355               case 0: //src
16356                 return false;
16357               case 1: //vdst
16358                 return true;
16359               default:
16360                 fatal("op idx %i out of bounds\n", opIdx);
16361                 return false;
16362             }
16363         } // isDstOperand
16364
16365         void execute(GPUDynInstPtr) override;
16366     }; // Inst_VOP1__V_CVT_F64_U32
16367
16368     class Inst_VOP1__V_TRUNC_F64 : public Inst_VOP1
16369     {
16370       public:
16371         Inst_VOP1__V_TRUNC_F64(InFmt_VOP1*);
16372         ~Inst_VOP1__V_TRUNC_F64();
16373
16374         int
16375         getNumOperands() override
16376         {
16377             return numDstRegOperands() + numSrcRegOperands();
16378         } // getNumOperands
16379
16380         int numDstRegOperands() override { return 1; }
16381         int numSrcRegOperands() override { return 1; }
16382
16383         int
16384         getOperandSize(int opIdx) override
16385         {
16386             switch (opIdx) {
16387               case 0: //src
16388                 return 8;
16389               case 1: //vdst
16390                 return 8;
16391               default:
16392                 fatal("op idx %i out of bounds\n", opIdx);
16393                 return -1;
16394             }
16395         } // getOperandSize
16396
16397         bool
16398         isSrcOperand(int opIdx) override
16399         {
16400             switch (opIdx) {
16401               case 0: //src
16402                 return true;
16403               case 1: //vdst
16404                 return false;
16405               default:
16406                 fatal("op idx %i out of bounds\n", opIdx);
16407                 return false;
16408             }
16409         } // isSrcOperand
16410
16411         bool
16412         isDstOperand(int opIdx) override
16413         {
16414             switch (opIdx) {
16415               case 0: //src
16416                 return false;
16417               case 1: //vdst
16418                 return true;
16419               default:
16420                 fatal("op idx %i out of bounds\n", opIdx);
16421                 return false;
16422             }
16423         } // isDstOperand
16424
16425         void execute(GPUDynInstPtr) override;
16426     }; // Inst_VOP1__V_TRUNC_F64
16427
16428     class Inst_VOP1__V_CEIL_F64 : public Inst_VOP1
16429     {
16430       public:
16431         Inst_VOP1__V_CEIL_F64(InFmt_VOP1*);
16432         ~Inst_VOP1__V_CEIL_F64();
16433
16434         int
16435         getNumOperands() override
16436         {
16437             return numDstRegOperands() + numSrcRegOperands();
16438         } // getNumOperands
16439
16440         int numDstRegOperands() override { return 1; }
16441         int numSrcRegOperands() override { return 1; }
16442
16443         int
16444         getOperandSize(int opIdx) override
16445         {
16446             switch (opIdx) {
16447               case 0: //src
16448                 return 8;
16449               case 1: //vdst
16450                 return 8;
16451               default:
16452                 fatal("op idx %i out of bounds\n", opIdx);
16453                 return -1;
16454             }
16455         } // getOperandSize
16456
16457         bool
16458         isSrcOperand(int opIdx) override
16459         {
16460             switch (opIdx) {
16461               case 0: //src
16462                 return true;
16463               case 1: //vdst
16464                 return false;
16465               default:
16466                 fatal("op idx %i out of bounds\n", opIdx);
16467                 return false;
16468             }
16469         } // isSrcOperand
16470
16471         bool
16472         isDstOperand(int opIdx) override
16473         {
16474             switch (opIdx) {
16475               case 0: //src
16476                 return false;
16477               case 1: //vdst
16478                 return true;
16479               default:
16480                 fatal("op idx %i out of bounds\n", opIdx);
16481                 return false;
16482             }
16483         } // isDstOperand
16484
16485         void execute(GPUDynInstPtr) override;
16486     }; // Inst_VOP1__V_CEIL_F64
16487
16488     class Inst_VOP1__V_RNDNE_F64 : public Inst_VOP1
16489     {
16490       public:
16491         Inst_VOP1__V_RNDNE_F64(InFmt_VOP1*);
16492         ~Inst_VOP1__V_RNDNE_F64();
16493
16494         int
16495         getNumOperands() override
16496         {
16497             return numDstRegOperands() + numSrcRegOperands();
16498         } // getNumOperands
16499
16500         int numDstRegOperands() override { return 1; }
16501         int numSrcRegOperands() override { return 1; }
16502
16503         int
16504         getOperandSize(int opIdx) override
16505         {
16506             switch (opIdx) {
16507               case 0: //src
16508                 return 8;
16509               case 1: //vdst
16510                 return 8;
16511               default:
16512                 fatal("op idx %i out of bounds\n", opIdx);
16513                 return -1;
16514             }
16515         } // getOperandSize
16516
16517         bool
16518         isSrcOperand(int opIdx) override
16519         {
16520             switch (opIdx) {
16521               case 0: //src
16522                 return true;
16523               case 1: //vdst
16524                 return false;
16525               default:
16526                 fatal("op idx %i out of bounds\n", opIdx);
16527                 return false;
16528             }
16529         } // isSrcOperand
16530
16531         bool
16532         isDstOperand(int opIdx) override
16533         {
16534             switch (opIdx) {
16535               case 0: //src
16536                 return false;
16537               case 1: //vdst
16538                 return true;
16539               default:
16540                 fatal("op idx %i out of bounds\n", opIdx);
16541                 return false;
16542             }
16543         } // isDstOperand
16544
16545         void execute(GPUDynInstPtr) override;
16546     }; // Inst_VOP1__V_RNDNE_F64
16547
16548     class Inst_VOP1__V_FLOOR_F64 : public Inst_VOP1
16549     {
16550       public:
16551         Inst_VOP1__V_FLOOR_F64(InFmt_VOP1*);
16552         ~Inst_VOP1__V_FLOOR_F64();
16553
16554         int
16555         getNumOperands() override
16556         {
16557             return numDstRegOperands() + numSrcRegOperands();
16558         } // getNumOperands
16559
16560         int numDstRegOperands() override { return 1; }
16561         int numSrcRegOperands() override { return 1; }
16562
16563         int
16564         getOperandSize(int opIdx) override
16565         {
16566             switch (opIdx) {
16567               case 0: //src
16568                 return 8;
16569               case 1: //vdst
16570                 return 8;
16571               default:
16572                 fatal("op idx %i out of bounds\n", opIdx);
16573                 return -1;
16574             }
16575         } // getOperandSize
16576
16577         bool
16578         isSrcOperand(int opIdx) override
16579         {
16580             switch (opIdx) {
16581               case 0: //src
16582                 return true;
16583               case 1: //vdst
16584                 return false;
16585               default:
16586                 fatal("op idx %i out of bounds\n", opIdx);
16587                 return false;
16588             }
16589         } // isSrcOperand
16590
16591         bool
16592         isDstOperand(int opIdx) override
16593         {
16594             switch (opIdx) {
16595               case 0: //src
16596                 return false;
16597               case 1: //vdst
16598                 return true;
16599               default:
16600                 fatal("op idx %i out of bounds\n", opIdx);
16601                 return false;
16602             }
16603         } // isDstOperand
16604
16605         void execute(GPUDynInstPtr) override;
16606     }; // Inst_VOP1__V_FLOOR_F64
16607
16608     class Inst_VOP1__V_FRACT_F32 : public Inst_VOP1
16609     {
16610       public:
16611         Inst_VOP1__V_FRACT_F32(InFmt_VOP1*);
16612         ~Inst_VOP1__V_FRACT_F32();
16613
16614         int
16615         getNumOperands() override
16616         {
16617             return numDstRegOperands() + numSrcRegOperands();
16618         } // getNumOperands
16619
16620         int numDstRegOperands() override { return 1; }
16621         int numSrcRegOperands() override { return 1; }
16622
16623         int
16624         getOperandSize(int opIdx) override
16625         {
16626             switch (opIdx) {
16627               case 0: //src
16628                 return 4;
16629               case 1: //vdst
16630                 return 4;
16631               default:
16632                 fatal("op idx %i out of bounds\n", opIdx);
16633                 return -1;
16634             }
16635         } // getOperandSize
16636
16637         bool
16638         isSrcOperand(int opIdx) override
16639         {
16640             switch (opIdx) {
16641               case 0: //src
16642                 return true;
16643               case 1: //vdst
16644                 return false;
16645               default:
16646                 fatal("op idx %i out of bounds\n", opIdx);
16647                 return false;
16648             }
16649         } // isSrcOperand
16650
16651         bool
16652         isDstOperand(int opIdx) override
16653         {
16654             switch (opIdx) {
16655               case 0: //src
16656                 return false;
16657               case 1: //vdst
16658                 return true;
16659               default:
16660                 fatal("op idx %i out of bounds\n", opIdx);
16661                 return false;
16662             }
16663         } // isDstOperand
16664
16665         void execute(GPUDynInstPtr) override;
16666     }; // Inst_VOP1__V_FRACT_F32
16667
16668     class Inst_VOP1__V_TRUNC_F32 : public Inst_VOP1
16669     {
16670       public:
16671         Inst_VOP1__V_TRUNC_F32(InFmt_VOP1*);
16672         ~Inst_VOP1__V_TRUNC_F32();
16673
16674         int
16675         getNumOperands() override
16676         {
16677             return numDstRegOperands() + numSrcRegOperands();
16678         } // getNumOperands
16679
16680         int numDstRegOperands() override { return 1; }
16681         int numSrcRegOperands() override { return 1; }
16682
16683         int
16684         getOperandSize(int opIdx) override
16685         {
16686             switch (opIdx) {
16687               case 0: //src
16688                 return 4;
16689               case 1: //vdst
16690                 return 4;
16691               default:
16692                 fatal("op idx %i out of bounds\n", opIdx);
16693                 return -1;
16694             }
16695         } // getOperandSize
16696
16697         bool
16698         isSrcOperand(int opIdx) override
16699         {
16700             switch (opIdx) {
16701               case 0: //src
16702                 return true;
16703               case 1: //vdst
16704                 return false;
16705               default:
16706                 fatal("op idx %i out of bounds\n", opIdx);
16707                 return false;
16708             }
16709         } // isSrcOperand
16710
16711         bool
16712         isDstOperand(int opIdx) override
16713         {
16714             switch (opIdx) {
16715               case 0: //src
16716                 return false;
16717               case 1: //vdst
16718                 return true;
16719               default:
16720                 fatal("op idx %i out of bounds\n", opIdx);
16721                 return false;
16722             }
16723         } // isDstOperand
16724
16725         void execute(GPUDynInstPtr) override;
16726     }; // Inst_VOP1__V_TRUNC_F32
16727
16728     class Inst_VOP1__V_CEIL_F32 : public Inst_VOP1
16729     {
16730       public:
16731         Inst_VOP1__V_CEIL_F32(InFmt_VOP1*);
16732         ~Inst_VOP1__V_CEIL_F32();
16733
16734         int
16735         getNumOperands() override
16736         {
16737             return numDstRegOperands() + numSrcRegOperands();
16738         } // getNumOperands
16739
16740         int numDstRegOperands() override { return 1; }
16741         int numSrcRegOperands() override { return 1; }
16742
16743         int
16744         getOperandSize(int opIdx) override
16745         {
16746             switch (opIdx) {
16747               case 0: //src
16748                 return 4;
16749               case 1: //vdst
16750                 return 4;
16751               default:
16752                 fatal("op idx %i out of bounds\n", opIdx);
16753                 return -1;
16754             }
16755         } // getOperandSize
16756
16757         bool
16758         isSrcOperand(int opIdx) override
16759         {
16760             switch (opIdx) {
16761               case 0: //src
16762                 return true;
16763               case 1: //vdst
16764                 return false;
16765               default:
16766                 fatal("op idx %i out of bounds\n", opIdx);
16767                 return false;
16768             }
16769         } // isSrcOperand
16770
16771         bool
16772         isDstOperand(int opIdx) override
16773         {
16774             switch (opIdx) {
16775               case 0: //src
16776                 return false;
16777               case 1: //vdst
16778                 return true;
16779               default:
16780                 fatal("op idx %i out of bounds\n", opIdx);
16781                 return false;
16782             }
16783         } // isDstOperand
16784
16785         void execute(GPUDynInstPtr) override;
16786     }; // Inst_VOP1__V_CEIL_F32
16787
16788     class Inst_VOP1__V_RNDNE_F32 : public Inst_VOP1
16789     {
16790       public:
16791         Inst_VOP1__V_RNDNE_F32(InFmt_VOP1*);
16792         ~Inst_VOP1__V_RNDNE_F32();
16793
16794         int
16795         getNumOperands() override
16796         {
16797             return numDstRegOperands() + numSrcRegOperands();
16798         } // getNumOperands
16799
16800         int numDstRegOperands() override { return 1; }
16801         int numSrcRegOperands() override { return 1; }
16802
16803         int
16804         getOperandSize(int opIdx) override
16805         {
16806             switch (opIdx) {
16807               case 0: //src
16808                 return 4;
16809               case 1: //vdst
16810                 return 4;
16811               default:
16812                 fatal("op idx %i out of bounds\n", opIdx);
16813                 return -1;
16814             }
16815         } // getOperandSize
16816
16817         bool
16818         isSrcOperand(int opIdx) override
16819         {
16820             switch (opIdx) {
16821               case 0: //src
16822                 return true;
16823               case 1: //vdst
16824                 return false;
16825               default:
16826                 fatal("op idx %i out of bounds\n", opIdx);
16827                 return false;
16828             }
16829         } // isSrcOperand
16830
16831         bool
16832         isDstOperand(int opIdx) override
16833         {
16834             switch (opIdx) {
16835               case 0: //src
16836                 return false;
16837               case 1: //vdst
16838                 return true;
16839               default:
16840                 fatal("op idx %i out of bounds\n", opIdx);
16841                 return false;
16842             }
16843         } // isDstOperand
16844
16845         void execute(GPUDynInstPtr) override;
16846     }; // Inst_VOP1__V_RNDNE_F32
16847
16848     class Inst_VOP1__V_FLOOR_F32 : public Inst_VOP1
16849     {
16850       public:
16851         Inst_VOP1__V_FLOOR_F32(InFmt_VOP1*);
16852         ~Inst_VOP1__V_FLOOR_F32();
16853
16854         int
16855         getNumOperands() override
16856         {
16857             return numDstRegOperands() + numSrcRegOperands();
16858         } // getNumOperands
16859
16860         int numDstRegOperands() override { return 1; }
16861         int numSrcRegOperands() override { return 1; }
16862
16863         int
16864         getOperandSize(int opIdx) override
16865         {
16866             switch (opIdx) {
16867               case 0: //src
16868                 return 4;
16869               case 1: //vdst
16870                 return 4;
16871               default:
16872                 fatal("op idx %i out of bounds\n", opIdx);
16873                 return -1;
16874             }
16875         } // getOperandSize
16876
16877         bool
16878         isSrcOperand(int opIdx) override
16879         {
16880             switch (opIdx) {
16881               case 0: //src
16882                 return true;
16883               case 1: //vdst
16884                 return false;
16885               default:
16886                 fatal("op idx %i out of bounds\n", opIdx);
16887                 return false;
16888             }
16889         } // isSrcOperand
16890
16891         bool
16892         isDstOperand(int opIdx) override
16893         {
16894             switch (opIdx) {
16895               case 0: //src
16896                 return false;
16897               case 1: //vdst
16898                 return true;
16899               default:
16900                 fatal("op idx %i out of bounds\n", opIdx);
16901                 return false;
16902             }
16903         } // isDstOperand
16904
16905         void execute(GPUDynInstPtr) override;
16906     }; // Inst_VOP1__V_FLOOR_F32
16907
16908     class Inst_VOP1__V_EXP_F32 : public Inst_VOP1
16909     {
16910       public:
16911         Inst_VOP1__V_EXP_F32(InFmt_VOP1*);
16912         ~Inst_VOP1__V_EXP_F32();
16913
16914         int
16915         getNumOperands() override
16916         {
16917             return numDstRegOperands() + numSrcRegOperands();
16918         } // getNumOperands
16919
16920         int numDstRegOperands() override { return 1; }
16921         int numSrcRegOperands() override { return 1; }
16922
16923         int
16924         getOperandSize(int opIdx) override
16925         {
16926             switch (opIdx) {
16927               case 0: //src
16928                 return 4;
16929               case 1: //vdst
16930                 return 4;
16931               default:
16932                 fatal("op idx %i out of bounds\n", opIdx);
16933                 return -1;
16934             }
16935         } // getOperandSize
16936
16937         bool
16938         isSrcOperand(int opIdx) override
16939         {
16940             switch (opIdx) {
16941               case 0: //src
16942                 return true;
16943               case 1: //vdst
16944                 return false;
16945               default:
16946                 fatal("op idx %i out of bounds\n", opIdx);
16947                 return false;
16948             }
16949         } // isSrcOperand
16950
16951         bool
16952         isDstOperand(int opIdx) override
16953         {
16954             switch (opIdx) {
16955               case 0: //src
16956                 return false;
16957               case 1: //vdst
16958                 return true;
16959               default:
16960                 fatal("op idx %i out of bounds\n", opIdx);
16961                 return false;
16962             }
16963         } // isDstOperand
16964
16965         void execute(GPUDynInstPtr) override;
16966     }; // Inst_VOP1__V_EXP_F32
16967
16968     class Inst_VOP1__V_LOG_F32 : public Inst_VOP1
16969     {
16970       public:
16971         Inst_VOP1__V_LOG_F32(InFmt_VOP1*);
16972         ~Inst_VOP1__V_LOG_F32();
16973
16974         int
16975         getNumOperands() override
16976         {
16977             return numDstRegOperands() + numSrcRegOperands();
16978         } // getNumOperands
16979
16980         int numDstRegOperands() override { return 1; }
16981         int numSrcRegOperands() override { return 1; }
16982
16983         int
16984         getOperandSize(int opIdx) override
16985         {
16986             switch (opIdx) {
16987               case 0: //src
16988                 return 4;
16989               case 1: //vdst
16990                 return 4;
16991               default:
16992                 fatal("op idx %i out of bounds\n", opIdx);
16993                 return -1;
16994             }
16995         } // getOperandSize
16996
16997         bool
16998         isSrcOperand(int opIdx) override
16999         {
17000             switch (opIdx) {
17001               case 0: //src
17002                 return true;
17003               case 1: //vdst
17004                 return false;
17005               default:
17006                 fatal("op idx %i out of bounds\n", opIdx);
17007                 return false;
17008             }
17009         } // isSrcOperand
17010
17011         bool
17012         isDstOperand(int opIdx) override
17013         {
17014             switch (opIdx) {
17015               case 0: //src
17016                 return false;
17017               case 1: //vdst
17018                 return true;
17019               default:
17020                 fatal("op idx %i out of bounds\n", opIdx);
17021                 return false;
17022             }
17023         } // isDstOperand
17024
17025         void execute(GPUDynInstPtr) override;
17026     }; // Inst_VOP1__V_LOG_F32
17027
17028     class Inst_VOP1__V_RCP_F32 : public Inst_VOP1
17029     {
17030       public:
17031         Inst_VOP1__V_RCP_F32(InFmt_VOP1*);
17032         ~Inst_VOP1__V_RCP_F32();
17033
17034         int
17035         getNumOperands() override
17036         {
17037             return numDstRegOperands() + numSrcRegOperands();
17038         } // getNumOperands
17039
17040         int numDstRegOperands() override { return 1; }
17041         int numSrcRegOperands() override { return 1; }
17042
17043         int
17044         getOperandSize(int opIdx) override
17045         {
17046             switch (opIdx) {
17047               case 0: //src
17048                 return 4;
17049               case 1: //vdst
17050                 return 4;
17051               default:
17052                 fatal("op idx %i out of bounds\n", opIdx);
17053                 return -1;
17054             }
17055         } // getOperandSize
17056
17057         bool
17058         isSrcOperand(int opIdx) override
17059         {
17060             switch (opIdx) {
17061               case 0: //src
17062                 return true;
17063               case 1: //vdst
17064                 return false;
17065               default:
17066                 fatal("op idx %i out of bounds\n", opIdx);
17067                 return false;
17068             }
17069         } // isSrcOperand
17070
17071         bool
17072         isDstOperand(int opIdx) override
17073         {
17074             switch (opIdx) {
17075               case 0: //src
17076                 return false;
17077               case 1: //vdst
17078                 return true;
17079               default:
17080                 fatal("op idx %i out of bounds\n", opIdx);
17081                 return false;
17082             }
17083         } // isDstOperand
17084
17085         void execute(GPUDynInstPtr) override;
17086     }; // Inst_VOP1__V_RCP_F32
17087
17088     class Inst_VOP1__V_RCP_IFLAG_F32 : public Inst_VOP1
17089     {
17090       public:
17091         Inst_VOP1__V_RCP_IFLAG_F32(InFmt_VOP1*);
17092         ~Inst_VOP1__V_RCP_IFLAG_F32();
17093
17094         int
17095         getNumOperands() override
17096         {
17097             return numDstRegOperands() + numSrcRegOperands();
17098         } // getNumOperands
17099
17100         int numDstRegOperands() override { return 1; }
17101         int numSrcRegOperands() override { return 1; }
17102
17103         int
17104         getOperandSize(int opIdx) override
17105         {
17106             switch (opIdx) {
17107               case 0: //src
17108                 return 4;
17109               case 1: //vdst
17110                 return 4;
17111               default:
17112                 fatal("op idx %i out of bounds\n", opIdx);
17113                 return -1;
17114             }
17115         } // getOperandSize
17116
17117         bool
17118         isSrcOperand(int opIdx) override
17119         {
17120             switch (opIdx) {
17121               case 0: //src
17122                 return true;
17123               case 1: //vdst
17124                 return false;
17125               default:
17126                 fatal("op idx %i out of bounds\n", opIdx);
17127                 return false;
17128             }
17129         } // isSrcOperand
17130
17131         bool
17132         isDstOperand(int opIdx) override
17133         {
17134             switch (opIdx) {
17135               case 0: //src
17136                 return false;
17137               case 1: //vdst
17138                 return true;
17139               default:
17140                 fatal("op idx %i out of bounds\n", opIdx);
17141                 return false;
17142             }
17143         } // isDstOperand
17144
17145         void execute(GPUDynInstPtr) override;
17146     }; // Inst_VOP1__V_RCP_IFLAG_F32
17147
17148     class Inst_VOP1__V_RSQ_F32 : public Inst_VOP1
17149     {
17150       public:
17151         Inst_VOP1__V_RSQ_F32(InFmt_VOP1*);
17152         ~Inst_VOP1__V_RSQ_F32();
17153
17154         int
17155         getNumOperands() override
17156         {
17157             return numDstRegOperands() + numSrcRegOperands();
17158         } // getNumOperands
17159
17160         int numDstRegOperands() override { return 1; }
17161         int numSrcRegOperands() override { return 1; }
17162
17163         int
17164         getOperandSize(int opIdx) override
17165         {
17166             switch (opIdx) {
17167               case 0: //src
17168                 return 4;
17169               case 1: //vdst
17170                 return 4;
17171               default:
17172                 fatal("op idx %i out of bounds\n", opIdx);
17173                 return -1;
17174             }
17175         } // getOperandSize
17176
17177         bool
17178         isSrcOperand(int opIdx) override
17179         {
17180             switch (opIdx) {
17181               case 0: //src
17182                 return true;
17183               case 1: //vdst
17184                 return false;
17185               default:
17186                 fatal("op idx %i out of bounds\n", opIdx);
17187                 return false;
17188             }
17189         } // isSrcOperand
17190
17191         bool
17192         isDstOperand(int opIdx) override
17193         {
17194             switch (opIdx) {
17195               case 0: //src
17196                 return false;
17197               case 1: //vdst
17198                 return true;
17199               default:
17200                 fatal("op idx %i out of bounds\n", opIdx);
17201                 return false;
17202             }
17203         } // isDstOperand
17204
17205         void execute(GPUDynInstPtr) override;
17206     }; // Inst_VOP1__V_RSQ_F32
17207
17208     class Inst_VOP1__V_RCP_F64 : public Inst_VOP1
17209     {
17210       public:
17211         Inst_VOP1__V_RCP_F64(InFmt_VOP1*);
17212         ~Inst_VOP1__V_RCP_F64();
17213
17214         int
17215         getNumOperands() override
17216         {
17217             return numDstRegOperands() + numSrcRegOperands();
17218         } // getNumOperands
17219
17220         int numDstRegOperands() override { return 1; }
17221         int numSrcRegOperands() override { return 1; }
17222
17223         int
17224         getOperandSize(int opIdx) override
17225         {
17226             switch (opIdx) {
17227               case 0: //src
17228                 return 8;
17229               case 1: //vdst
17230                 return 8;
17231               default:
17232                 fatal("op idx %i out of bounds\n", opIdx);
17233                 return -1;
17234             }
17235         } // getOperandSize
17236
17237         bool
17238         isSrcOperand(int opIdx) override
17239         {
17240             switch (opIdx) {
17241               case 0: //src
17242                 return true;
17243               case 1: //vdst
17244                 return false;
17245               default:
17246                 fatal("op idx %i out of bounds\n", opIdx);
17247                 return false;
17248             }
17249         } // isSrcOperand
17250
17251         bool
17252         isDstOperand(int opIdx) override
17253         {
17254             switch (opIdx) {
17255               case 0: //src
17256                 return false;
17257               case 1: //vdst
17258                 return true;
17259               default:
17260                 fatal("op idx %i out of bounds\n", opIdx);
17261                 return false;
17262             }
17263         } // isDstOperand
17264
17265         void execute(GPUDynInstPtr) override;
17266     }; // Inst_VOP1__V_RCP_F64
17267
17268     class Inst_VOP1__V_RSQ_F64 : public Inst_VOP1
17269     {
17270       public:
17271         Inst_VOP1__V_RSQ_F64(InFmt_VOP1*);
17272         ~Inst_VOP1__V_RSQ_F64();
17273
17274         int
17275         getNumOperands() override
17276         {
17277             return numDstRegOperands() + numSrcRegOperands();
17278         } // getNumOperands
17279
17280         int numDstRegOperands() override { return 1; }
17281         int numSrcRegOperands() override { return 1; }
17282
17283         int
17284         getOperandSize(int opIdx) override
17285         {
17286             switch (opIdx) {
17287               case 0: //src
17288                 return 8;
17289               case 1: //vdst
17290                 return 8;
17291               default:
17292                 fatal("op idx %i out of bounds\n", opIdx);
17293                 return -1;
17294             }
17295         } // getOperandSize
17296
17297         bool
17298         isSrcOperand(int opIdx) override
17299         {
17300             switch (opIdx) {
17301               case 0: //src
17302                 return true;
17303               case 1: //vdst
17304                 return false;
17305               default:
17306                 fatal("op idx %i out of bounds\n", opIdx);
17307                 return false;
17308             }
17309         } // isSrcOperand
17310
17311         bool
17312         isDstOperand(int opIdx) override
17313         {
17314             switch (opIdx) {
17315               case 0: //src
17316                 return false;
17317               case 1: //vdst
17318                 return true;
17319               default:
17320                 fatal("op idx %i out of bounds\n", opIdx);
17321                 return false;
17322             }
17323         } // isDstOperand
17324
17325         void execute(GPUDynInstPtr) override;
17326     }; // Inst_VOP1__V_RSQ_F64
17327
17328     class Inst_VOP1__V_SQRT_F32 : public Inst_VOP1
17329     {
17330       public:
17331         Inst_VOP1__V_SQRT_F32(InFmt_VOP1*);
17332         ~Inst_VOP1__V_SQRT_F32();
17333
17334         int
17335         getNumOperands() override
17336         {
17337             return numDstRegOperands() + numSrcRegOperands();
17338         } // getNumOperands
17339
17340         int numDstRegOperands() override { return 1; }
17341         int numSrcRegOperands() override { return 1; }
17342
17343         int
17344         getOperandSize(int opIdx) override
17345         {
17346             switch (opIdx) {
17347               case 0: //src
17348                 return 4;
17349               case 1: //vdst
17350                 return 4;
17351               default:
17352                 fatal("op idx %i out of bounds\n", opIdx);
17353                 return -1;
17354             }
17355         } // getOperandSize
17356
17357         bool
17358         isSrcOperand(int opIdx) override
17359         {
17360             switch (opIdx) {
17361               case 0: //src
17362                 return true;
17363               case 1: //vdst
17364                 return false;
17365               default:
17366                 fatal("op idx %i out of bounds\n", opIdx);
17367                 return false;
17368             }
17369         } // isSrcOperand
17370
17371         bool
17372         isDstOperand(int opIdx) override
17373         {
17374             switch (opIdx) {
17375               case 0: //src
17376                 return false;
17377               case 1: //vdst
17378                 return true;
17379               default:
17380                 fatal("op idx %i out of bounds\n", opIdx);
17381                 return false;
17382             }
17383         } // isDstOperand
17384
17385         void execute(GPUDynInstPtr) override;
17386     }; // Inst_VOP1__V_SQRT_F32
17387
17388     class Inst_VOP1__V_SQRT_F64 : public Inst_VOP1
17389     {
17390       public:
17391         Inst_VOP1__V_SQRT_F64(InFmt_VOP1*);
17392         ~Inst_VOP1__V_SQRT_F64();
17393
17394         int
17395         getNumOperands() override
17396         {
17397             return numDstRegOperands() + numSrcRegOperands();
17398         } // getNumOperands
17399
17400         int numDstRegOperands() override { return 1; }
17401         int numSrcRegOperands() override { return 1; }
17402
17403         int
17404         getOperandSize(int opIdx) override
17405         {
17406             switch (opIdx) {
17407               case 0: //src
17408                 return 8;
17409               case 1: //vdst
17410                 return 8;
17411               default:
17412                 fatal("op idx %i out of bounds\n", opIdx);
17413                 return -1;
17414             }
17415         } // getOperandSize
17416
17417         bool
17418         isSrcOperand(int opIdx) override
17419         {
17420             switch (opIdx) {
17421               case 0: //src
17422                 return true;
17423               case 1: //vdst
17424                 return false;
17425               default:
17426                 fatal("op idx %i out of bounds\n", opIdx);
17427                 return false;
17428             }
17429         } // isSrcOperand
17430
17431         bool
17432         isDstOperand(int opIdx) override
17433         {
17434             switch (opIdx) {
17435               case 0: //src
17436                 return false;
17437               case 1: //vdst
17438                 return true;
17439               default:
17440                 fatal("op idx %i out of bounds\n", opIdx);
17441                 return false;
17442             }
17443         } // isDstOperand
17444
17445         void execute(GPUDynInstPtr) override;
17446     }; // Inst_VOP1__V_SQRT_F64
17447
17448     class Inst_VOP1__V_SIN_F32 : public Inst_VOP1
17449     {
17450       public:
17451         Inst_VOP1__V_SIN_F32(InFmt_VOP1*);
17452         ~Inst_VOP1__V_SIN_F32();
17453
17454         int
17455         getNumOperands() override
17456         {
17457             return numDstRegOperands() + numSrcRegOperands();
17458         } // getNumOperands
17459
17460         int numDstRegOperands() override { return 1; }
17461         int numSrcRegOperands() override { return 1; }
17462
17463         int
17464         getOperandSize(int opIdx) override
17465         {
17466             switch (opIdx) {
17467               case 0: //src
17468                 return 4;
17469               case 1: //vdst
17470                 return 4;
17471               default:
17472                 fatal("op idx %i out of bounds\n", opIdx);
17473                 return -1;
17474             }
17475         } // getOperandSize
17476
17477         bool
17478         isSrcOperand(int opIdx) override
17479         {
17480             switch (opIdx) {
17481               case 0: //src
17482                 return true;
17483               case 1: //vdst
17484                 return false;
17485               default:
17486                 fatal("op idx %i out of bounds\n", opIdx);
17487                 return false;
17488             }
17489         } // isSrcOperand
17490
17491         bool
17492         isDstOperand(int opIdx) override
17493         {
17494             switch (opIdx) {
17495               case 0: //src
17496                 return false;
17497               case 1: //vdst
17498                 return true;
17499               default:
17500                 fatal("op idx %i out of bounds\n", opIdx);
17501                 return false;
17502             }
17503         } // isDstOperand
17504
17505         void execute(GPUDynInstPtr) override;
17506     }; // Inst_VOP1__V_SIN_F32
17507
17508     class Inst_VOP1__V_COS_F32 : public Inst_VOP1
17509     {
17510       public:
17511         Inst_VOP1__V_COS_F32(InFmt_VOP1*);
17512         ~Inst_VOP1__V_COS_F32();
17513
17514         int
17515         getNumOperands() override
17516         {
17517             return numDstRegOperands() + numSrcRegOperands();
17518         } // getNumOperands
17519
17520         int numDstRegOperands() override { return 1; }
17521         int numSrcRegOperands() override { return 1; }
17522
17523         int
17524         getOperandSize(int opIdx) override
17525         {
17526             switch (opIdx) {
17527               case 0: //src
17528                 return 4;
17529               case 1: //vdst
17530                 return 4;
17531               default:
17532                 fatal("op idx %i out of bounds\n", opIdx);
17533                 return -1;
17534             }
17535         } // getOperandSize
17536
17537         bool
17538         isSrcOperand(int opIdx) override
17539         {
17540             switch (opIdx) {
17541               case 0: //src
17542                 return true;
17543               case 1: //vdst
17544                 return false;
17545               default:
17546                 fatal("op idx %i out of bounds\n", opIdx);
17547                 return false;
17548             }
17549         } // isSrcOperand
17550
17551         bool
17552         isDstOperand(int opIdx) override
17553         {
17554             switch (opIdx) {
17555               case 0: //src
17556                 return false;
17557               case 1: //vdst
17558                 return true;
17559               default:
17560                 fatal("op idx %i out of bounds\n", opIdx);
17561                 return false;
17562             }
17563         } // isDstOperand
17564
17565         void execute(GPUDynInstPtr) override;
17566     }; // Inst_VOP1__V_COS_F32
17567
17568     class Inst_VOP1__V_NOT_B32 : public Inst_VOP1
17569     {
17570       public:
17571         Inst_VOP1__V_NOT_B32(InFmt_VOP1*);
17572         ~Inst_VOP1__V_NOT_B32();
17573
17574         int
17575         getNumOperands() override
17576         {
17577             return numDstRegOperands() + numSrcRegOperands();
17578         } // getNumOperands
17579
17580         int numDstRegOperands() override { return 1; }
17581         int numSrcRegOperands() override { return 1; }
17582
17583         int
17584         getOperandSize(int opIdx) override
17585         {
17586             switch (opIdx) {
17587               case 0: //src
17588                 return 4;
17589               case 1: //vdst
17590                 return 4;
17591               default:
17592                 fatal("op idx %i out of bounds\n", opIdx);
17593                 return -1;
17594             }
17595         } // getOperandSize
17596
17597         bool
17598         isSrcOperand(int opIdx) override
17599         {
17600             switch (opIdx) {
17601               case 0: //src
17602                 return true;
17603               case 1: //vdst
17604                 return false;
17605               default:
17606                 fatal("op idx %i out of bounds\n", opIdx);
17607                 return false;
17608             }
17609         } // isSrcOperand
17610
17611         bool
17612         isDstOperand(int opIdx) override
17613         {
17614             switch (opIdx) {
17615               case 0: //src
17616                 return false;
17617               case 1: //vdst
17618                 return true;
17619               default:
17620                 fatal("op idx %i out of bounds\n", opIdx);
17621                 return false;
17622             }
17623         } // isDstOperand
17624
17625         void execute(GPUDynInstPtr) override;
17626     }; // Inst_VOP1__V_NOT_B32
17627
17628     class Inst_VOP1__V_BFREV_B32 : public Inst_VOP1
17629     {
17630       public:
17631         Inst_VOP1__V_BFREV_B32(InFmt_VOP1*);
17632         ~Inst_VOP1__V_BFREV_B32();
17633
17634         int
17635         getNumOperands() override
17636         {
17637             return numDstRegOperands() + numSrcRegOperands();
17638         } // getNumOperands
17639
17640         int numDstRegOperands() override { return 1; }
17641         int numSrcRegOperands() override { return 1; }
17642
17643         int
17644         getOperandSize(int opIdx) override
17645         {
17646             switch (opIdx) {
17647               case 0: //src
17648                 return 4;
17649               case 1: //vdst
17650                 return 4;
17651               default:
17652                 fatal("op idx %i out of bounds\n", opIdx);
17653                 return -1;
17654             }
17655         } // getOperandSize
17656
17657         bool
17658         isSrcOperand(int opIdx) override
17659         {
17660             switch (opIdx) {
17661               case 0: //src
17662                 return true;
17663               case 1: //vdst
17664                 return false;
17665               default:
17666                 fatal("op idx %i out of bounds\n", opIdx);
17667                 return false;
17668             }
17669         } // isSrcOperand
17670
17671         bool
17672         isDstOperand(int opIdx) override
17673         {
17674             switch (opIdx) {
17675               case 0: //src
17676                 return false;
17677               case 1: //vdst
17678                 return true;
17679               default:
17680                 fatal("op idx %i out of bounds\n", opIdx);
17681                 return false;
17682             }
17683         } // isDstOperand
17684
17685         void execute(GPUDynInstPtr) override;
17686     }; // Inst_VOP1__V_BFREV_B32
17687
17688     class Inst_VOP1__V_FFBH_U32 : public Inst_VOP1
17689     {
17690       public:
17691         Inst_VOP1__V_FFBH_U32(InFmt_VOP1*);
17692         ~Inst_VOP1__V_FFBH_U32();
17693
17694         int
17695         getNumOperands() override
17696         {
17697             return numDstRegOperands() + numSrcRegOperands();
17698         } // getNumOperands
17699
17700         int numDstRegOperands() override { return 1; }
17701         int numSrcRegOperands() override { return 1; }
17702
17703         int
17704         getOperandSize(int opIdx) override
17705         {
17706             switch (opIdx) {
17707               case 0: //src
17708                 return 4;
17709               case 1: //vdst
17710                 return 4;
17711               default:
17712                 fatal("op idx %i out of bounds\n", opIdx);
17713                 return -1;
17714             }
17715         } // getOperandSize
17716
17717         bool
17718         isSrcOperand(int opIdx) override
17719         {
17720             switch (opIdx) {
17721               case 0: //src
17722                 return true;
17723               case 1: //vdst
17724                 return false;
17725               default:
17726                 fatal("op idx %i out of bounds\n", opIdx);
17727                 return false;
17728             }
17729         } // isSrcOperand
17730
17731         bool
17732         isDstOperand(int opIdx) override
17733         {
17734             switch (opIdx) {
17735               case 0: //src
17736                 return false;
17737               case 1: //vdst
17738                 return true;
17739               default:
17740                 fatal("op idx %i out of bounds\n", opIdx);
17741                 return false;
17742             }
17743         } // isDstOperand
17744
17745         void execute(GPUDynInstPtr) override;
17746     }; // Inst_VOP1__V_FFBH_U32
17747
17748     class Inst_VOP1__V_FFBL_B32 : public Inst_VOP1
17749     {
17750       public:
17751         Inst_VOP1__V_FFBL_B32(InFmt_VOP1*);
17752         ~Inst_VOP1__V_FFBL_B32();
17753
17754         int
17755         getNumOperands() override
17756         {
17757             return numDstRegOperands() + numSrcRegOperands();
17758         } // getNumOperands
17759
17760         int numDstRegOperands() override { return 1; }
17761         int numSrcRegOperands() override { return 1; }
17762
17763         int
17764         getOperandSize(int opIdx) override
17765         {
17766             switch (opIdx) {
17767               case 0: //src
17768                 return 4;
17769               case 1: //vdst
17770                 return 4;
17771               default:
17772                 fatal("op idx %i out of bounds\n", opIdx);
17773                 return -1;
17774             }
17775         } // getOperandSize
17776
17777         bool
17778         isSrcOperand(int opIdx) override
17779         {
17780             switch (opIdx) {
17781               case 0: //src
17782                 return true;
17783               case 1: //vdst
17784                 return false;
17785               default:
17786                 fatal("op idx %i out of bounds\n", opIdx);
17787                 return false;
17788             }
17789         } // isSrcOperand
17790
17791         bool
17792         isDstOperand(int opIdx) override
17793         {
17794             switch (opIdx) {
17795               case 0: //src
17796                 return false;
17797               case 1: //vdst
17798                 return true;
17799               default:
17800                 fatal("op idx %i out of bounds\n", opIdx);
17801                 return false;
17802             }
17803         } // isDstOperand
17804
17805         void execute(GPUDynInstPtr) override;
17806     }; // Inst_VOP1__V_FFBL_B32
17807
17808     class Inst_VOP1__V_FFBH_I32 : public Inst_VOP1
17809     {
17810       public:
17811         Inst_VOP1__V_FFBH_I32(InFmt_VOP1*);
17812         ~Inst_VOP1__V_FFBH_I32();
17813
17814         int
17815         getNumOperands() override
17816         {
17817             return numDstRegOperands() + numSrcRegOperands();
17818         } // getNumOperands
17819
17820         int numDstRegOperands() override { return 1; }
17821         int numSrcRegOperands() override { return 1; }
17822
17823         int
17824         getOperandSize(int opIdx) override
17825         {
17826             switch (opIdx) {
17827               case 0: //src
17828                 return 4;
17829               case 1: //vdst
17830                 return 4;
17831               default:
17832                 fatal("op idx %i out of bounds\n", opIdx);
17833                 return -1;
17834             }
17835         } // getOperandSize
17836
17837         bool
17838         isSrcOperand(int opIdx) override
17839         {
17840             switch (opIdx) {
17841               case 0: //src
17842                 return true;
17843               case 1: //vdst
17844                 return false;
17845               default:
17846                 fatal("op idx %i out of bounds\n", opIdx);
17847                 return false;
17848             }
17849         } // isSrcOperand
17850
17851         bool
17852         isDstOperand(int opIdx) override
17853         {
17854             switch (opIdx) {
17855               case 0: //src
17856                 return false;
17857               case 1: //vdst
17858                 return true;
17859               default:
17860                 fatal("op idx %i out of bounds\n", opIdx);
17861                 return false;
17862             }
17863         } // isDstOperand
17864
17865         void execute(GPUDynInstPtr) override;
17866     }; // Inst_VOP1__V_FFBH_I32
17867
17868     class Inst_VOP1__V_FREXP_EXP_I32_F64 : public Inst_VOP1
17869     {
17870       public:
17871         Inst_VOP1__V_FREXP_EXP_I32_F64(InFmt_VOP1*);
17872         ~Inst_VOP1__V_FREXP_EXP_I32_F64();
17873
17874         int
17875         getNumOperands() override
17876         {
17877             return numDstRegOperands() + numSrcRegOperands();
17878         } // getNumOperands
17879
17880         int numDstRegOperands() override { return 1; }
17881         int numSrcRegOperands() override { return 1; }
17882
17883         int
17884         getOperandSize(int opIdx) override
17885         {
17886             switch (opIdx) {
17887               case 0: //src
17888                 return 8;
17889               case 1: //vdst
17890                 return 4;
17891               default:
17892                 fatal("op idx %i out of bounds\n", opIdx);
17893                 return -1;
17894             }
17895         } // getOperandSize
17896
17897         bool
17898         isSrcOperand(int opIdx) override
17899         {
17900             switch (opIdx) {
17901               case 0: //src
17902                 return true;
17903               case 1: //vdst
17904                 return false;
17905               default:
17906                 fatal("op idx %i out of bounds\n", opIdx);
17907                 return false;
17908             }
17909         } // isSrcOperand
17910
17911         bool
17912         isDstOperand(int opIdx) override
17913         {
17914             switch (opIdx) {
17915               case 0: //src
17916                 return false;
17917               case 1: //vdst
17918                 return true;
17919               default:
17920                 fatal("op idx %i out of bounds\n", opIdx);
17921                 return false;
17922             }
17923         } // isDstOperand
17924
17925         void execute(GPUDynInstPtr) override;
17926     }; // Inst_VOP1__V_FREXP_EXP_I32_F64
17927
17928     class Inst_VOP1__V_FREXP_MANT_F64 : public Inst_VOP1
17929     {
17930       public:
17931         Inst_VOP1__V_FREXP_MANT_F64(InFmt_VOP1*);
17932         ~Inst_VOP1__V_FREXP_MANT_F64();
17933
17934         int
17935         getNumOperands() override
17936         {
17937             return numDstRegOperands() + numSrcRegOperands();
17938         } // getNumOperands
17939
17940         int numDstRegOperands() override { return 1; }
17941         int numSrcRegOperands() override { return 1; }
17942
17943         int
17944         getOperandSize(int opIdx) override
17945         {
17946             switch (opIdx) {
17947               case 0: //src
17948                 return 8;
17949               case 1: //vdst
17950                 return 8;
17951               default:
17952                 fatal("op idx %i out of bounds\n", opIdx);
17953                 return -1;
17954             }
17955         } // getOperandSize
17956
17957         bool
17958         isSrcOperand(int opIdx) override
17959         {
17960             switch (opIdx) {
17961               case 0: //src
17962                 return true;
17963               case 1: //vdst
17964                 return false;
17965               default:
17966                 fatal("op idx %i out of bounds\n", opIdx);
17967                 return false;
17968             }
17969         } // isSrcOperand
17970
17971         bool
17972         isDstOperand(int opIdx) override
17973         {
17974             switch (opIdx) {
17975               case 0: //src
17976                 return false;
17977               case 1: //vdst
17978                 return true;
17979               default:
17980                 fatal("op idx %i out of bounds\n", opIdx);
17981                 return false;
17982             }
17983         } // isDstOperand
17984
17985         void execute(GPUDynInstPtr) override;
17986     }; // Inst_VOP1__V_FREXP_MANT_F64
17987
17988     class Inst_VOP1__V_FRACT_F64 : public Inst_VOP1
17989     {
17990       public:
17991         Inst_VOP1__V_FRACT_F64(InFmt_VOP1*);
17992         ~Inst_VOP1__V_FRACT_F64();
17993
17994         int
17995         getNumOperands() override
17996         {
17997             return numDstRegOperands() + numSrcRegOperands();
17998         } // getNumOperands
17999
18000         int numDstRegOperands() override { return 1; }
18001         int numSrcRegOperands() override { return 1; }
18002
18003         int
18004         getOperandSize(int opIdx) override
18005         {
18006             switch (opIdx) {
18007               case 0: //src
18008                 return 8;
18009               case 1: //vdst
18010                 return 8;
18011               default:
18012                 fatal("op idx %i out of bounds\n", opIdx);
18013                 return -1;
18014             }
18015         } // getOperandSize
18016
18017         bool
18018         isSrcOperand(int opIdx) override
18019         {
18020             switch (opIdx) {
18021               case 0: //src
18022                 return true;
18023               case 1: //vdst
18024                 return false;
18025               default:
18026                 fatal("op idx %i out of bounds\n", opIdx);
18027                 return false;
18028             }
18029         } // isSrcOperand
18030
18031         bool
18032         isDstOperand(int opIdx) override
18033         {
18034             switch (opIdx) {
18035               case 0: //src
18036                 return false;
18037               case 1: //vdst
18038                 return true;
18039               default:
18040                 fatal("op idx %i out of bounds\n", opIdx);
18041                 return false;
18042             }
18043         } // isDstOperand
18044
18045         void execute(GPUDynInstPtr) override;
18046     }; // Inst_VOP1__V_FRACT_F64
18047
18048     class Inst_VOP1__V_FREXP_EXP_I32_F32 : public Inst_VOP1
18049     {
18050       public:
18051         Inst_VOP1__V_FREXP_EXP_I32_F32(InFmt_VOP1*);
18052         ~Inst_VOP1__V_FREXP_EXP_I32_F32();
18053
18054         int
18055         getNumOperands() override
18056         {
18057             return numDstRegOperands() + numSrcRegOperands();
18058         } // getNumOperands
18059
18060         int numDstRegOperands() override { return 1; }
18061         int numSrcRegOperands() override { return 1; }
18062
18063         int
18064         getOperandSize(int opIdx) override
18065         {
18066             switch (opIdx) {
18067               case 0: //src
18068                 return 4;
18069               case 1: //vdst
18070                 return 4;
18071               default:
18072                 fatal("op idx %i out of bounds\n", opIdx);
18073                 return -1;
18074             }
18075         } // getOperandSize
18076
18077         bool
18078         isSrcOperand(int opIdx) override
18079         {
18080             switch (opIdx) {
18081               case 0: //src
18082                 return true;
18083               case 1: //vdst
18084                 return false;
18085               default:
18086                 fatal("op idx %i out of bounds\n", opIdx);
18087                 return false;
18088             }
18089         } // isSrcOperand
18090
18091         bool
18092         isDstOperand(int opIdx) override
18093         {
18094             switch (opIdx) {
18095               case 0: //src
18096                 return false;
18097               case 1: //vdst
18098                 return true;
18099               default:
18100                 fatal("op idx %i out of bounds\n", opIdx);
18101                 return false;
18102             }
18103         } // isDstOperand
18104
18105         void execute(GPUDynInstPtr) override;
18106     }; // Inst_VOP1__V_FREXP_EXP_I32_F32
18107
18108     class Inst_VOP1__V_FREXP_MANT_F32 : public Inst_VOP1
18109     {
18110       public:
18111         Inst_VOP1__V_FREXP_MANT_F32(InFmt_VOP1*);
18112         ~Inst_VOP1__V_FREXP_MANT_F32();
18113
18114         int
18115         getNumOperands() override
18116         {
18117             return numDstRegOperands() + numSrcRegOperands();
18118         } // getNumOperands
18119
18120         int numDstRegOperands() override { return 1; }
18121         int numSrcRegOperands() override { return 1; }
18122
18123         int
18124         getOperandSize(int opIdx) override
18125         {
18126             switch (opIdx) {
18127               case 0: //src
18128                 return 4;
18129               case 1: //vdst
18130                 return 4;
18131               default:
18132                 fatal("op idx %i out of bounds\n", opIdx);
18133                 return -1;
18134             }
18135         } // getOperandSize
18136
18137         bool
18138         isSrcOperand(int opIdx) override
18139         {
18140             switch (opIdx) {
18141               case 0: //src
18142                 return true;
18143               case 1: //vdst
18144                 return false;
18145               default:
18146                 fatal("op idx %i out of bounds\n", opIdx);
18147                 return false;
18148             }
18149         } // isSrcOperand
18150
18151         bool
18152         isDstOperand(int opIdx) override
18153         {
18154             switch (opIdx) {
18155               case 0: //src
18156                 return false;
18157               case 1: //vdst
18158                 return true;
18159               default:
18160                 fatal("op idx %i out of bounds\n", opIdx);
18161                 return false;
18162             }
18163         } // isDstOperand
18164
18165         void execute(GPUDynInstPtr) override;
18166     }; // Inst_VOP1__V_FREXP_MANT_F32
18167
18168     class Inst_VOP1__V_CLREXCP : public Inst_VOP1
18169     {
18170       public:
18171         Inst_VOP1__V_CLREXCP(InFmt_VOP1*);
18172         ~Inst_VOP1__V_CLREXCP();
18173
18174         int
18175         getNumOperands() override
18176         {
18177             return numDstRegOperands() + numSrcRegOperands();
18178         } // getNumOperands
18179
18180         int numDstRegOperands() override { return 0; }
18181         int numSrcRegOperands() override { return 0; }
18182
18183         int
18184         getOperandSize(int opIdx) override
18185         {
18186             switch (opIdx) {
18187               default:
18188                 fatal("op idx %i out of bounds\n", opIdx);
18189                 return -1;
18190             }
18191         } // getOperandSize
18192
18193         bool
18194         isSrcOperand(int opIdx) override
18195         {
18196             switch (opIdx) {
18197               default:
18198                 fatal("op idx %i out of bounds\n", opIdx);
18199                 return false;
18200             }
18201         } // isSrcOperand
18202
18203         bool
18204         isDstOperand(int opIdx) override
18205         {
18206             switch (opIdx) {
18207               default:
18208                 fatal("op idx %i out of bounds\n", opIdx);
18209                 return false;
18210             }
18211         } // isDstOperand
18212
18213         void execute(GPUDynInstPtr) override;
18214     }; // Inst_VOP1__V_CLREXCP
18215
18216     class Inst_VOP1__V_CVT_F16_U16 : public Inst_VOP1
18217     {
18218       public:
18219         Inst_VOP1__V_CVT_F16_U16(InFmt_VOP1*);
18220         ~Inst_VOP1__V_CVT_F16_U16();
18221
18222         int
18223         getNumOperands() override
18224         {
18225             return numDstRegOperands() + numSrcRegOperands();
18226         } // getNumOperands
18227
18228         int numDstRegOperands() override { return 1; }
18229         int numSrcRegOperands() override { return 1; }
18230
18231         int
18232         getOperandSize(int opIdx) override
18233         {
18234             switch (opIdx) {
18235               case 0: //src
18236                 return 2;
18237               case 1: //vdst
18238                 return 2;
18239               default:
18240                 fatal("op idx %i out of bounds\n", opIdx);
18241                 return -1;
18242             }
18243         } // getOperandSize
18244
18245         bool
18246         isSrcOperand(int opIdx) override
18247         {
18248             switch (opIdx) {
18249               case 0: //src
18250                 return true;
18251               case 1: //vdst
18252                 return false;
18253               default:
18254                 fatal("op idx %i out of bounds\n", opIdx);
18255                 return false;
18256             }
18257         } // isSrcOperand
18258
18259         bool
18260         isDstOperand(int opIdx) override
18261         {
18262             switch (opIdx) {
18263               case 0: //src
18264                 return false;
18265               case 1: //vdst
18266                 return true;
18267               default:
18268                 fatal("op idx %i out of bounds\n", opIdx);
18269                 return false;
18270             }
18271         } // isDstOperand
18272
18273         void execute(GPUDynInstPtr) override;
18274     }; // Inst_VOP1__V_CVT_F16_U16
18275
18276     class Inst_VOP1__V_CVT_F16_I16 : public Inst_VOP1
18277     {
18278       public:
18279         Inst_VOP1__V_CVT_F16_I16(InFmt_VOP1*);
18280         ~Inst_VOP1__V_CVT_F16_I16();
18281
18282         int
18283         getNumOperands() override
18284         {
18285             return numDstRegOperands() + numSrcRegOperands();
18286         } // getNumOperands
18287
18288         int numDstRegOperands() override { return 1; }
18289         int numSrcRegOperands() override { return 1; }
18290
18291         int
18292         getOperandSize(int opIdx) override
18293         {
18294             switch (opIdx) {
18295               case 0: //src
18296                 return 2;
18297               case 1: //vdst
18298                 return 2;
18299               default:
18300                 fatal("op idx %i out of bounds\n", opIdx);
18301                 return -1;
18302             }
18303         } // getOperandSize
18304
18305         bool
18306         isSrcOperand(int opIdx) override
18307         {
18308             switch (opIdx) {
18309               case 0: //src
18310                 return true;
18311               case 1: //vdst
18312                 return false;
18313               default:
18314                 fatal("op idx %i out of bounds\n", opIdx);
18315                 return false;
18316             }
18317         } // isSrcOperand
18318
18319         bool
18320         isDstOperand(int opIdx) override
18321         {
18322             switch (opIdx) {
18323               case 0: //src
18324                 return false;
18325               case 1: //vdst
18326                 return true;
18327               default:
18328                 fatal("op idx %i out of bounds\n", opIdx);
18329                 return false;
18330             }
18331         } // isDstOperand
18332
18333         void execute(GPUDynInstPtr) override;
18334     }; // Inst_VOP1__V_CVT_F16_I16
18335
18336     class Inst_VOP1__V_CVT_U16_F16 : public Inst_VOP1
18337     {
18338       public:
18339         Inst_VOP1__V_CVT_U16_F16(InFmt_VOP1*);
18340         ~Inst_VOP1__V_CVT_U16_F16();
18341
18342         int
18343         getNumOperands() override
18344         {
18345             return numDstRegOperands() + numSrcRegOperands();
18346         } // getNumOperands
18347
18348         int numDstRegOperands() override { return 1; }
18349         int numSrcRegOperands() override { return 1; }
18350
18351         int
18352         getOperandSize(int opIdx) override
18353         {
18354             switch (opIdx) {
18355               case 0: //src
18356                 return 2;
18357               case 1: //vdst
18358                 return 2;
18359               default:
18360                 fatal("op idx %i out of bounds\n", opIdx);
18361                 return -1;
18362             }
18363         } // getOperandSize
18364
18365         bool
18366         isSrcOperand(int opIdx) override
18367         {
18368             switch (opIdx) {
18369               case 0: //src
18370                 return true;
18371               case 1: //vdst
18372                 return false;
18373               default:
18374                 fatal("op idx %i out of bounds\n", opIdx);
18375                 return false;
18376             }
18377         } // isSrcOperand
18378
18379         bool
18380         isDstOperand(int opIdx) override
18381         {
18382             switch (opIdx) {
18383               case 0: //src
18384                 return false;
18385               case 1: //vdst
18386                 return true;
18387               default:
18388                 fatal("op idx %i out of bounds\n", opIdx);
18389                 return false;
18390             }
18391         } // isDstOperand
18392
18393         void execute(GPUDynInstPtr) override;
18394     }; // Inst_VOP1__V_CVT_U16_F16
18395
18396     class Inst_VOP1__V_CVT_I16_F16 : public Inst_VOP1
18397     {
18398       public:
18399         Inst_VOP1__V_CVT_I16_F16(InFmt_VOP1*);
18400         ~Inst_VOP1__V_CVT_I16_F16();
18401
18402         int
18403         getNumOperands() override
18404         {
18405             return numDstRegOperands() + numSrcRegOperands();
18406         } // getNumOperands
18407
18408         int numDstRegOperands() override { return 1; }
18409         int numSrcRegOperands() override { return 1; }
18410
18411         int
18412         getOperandSize(int opIdx) override
18413         {
18414             switch (opIdx) {
18415               case 0: //src
18416                 return 2;
18417               case 1: //vdst
18418                 return 2;
18419               default:
18420                 fatal("op idx %i out of bounds\n", opIdx);
18421                 return -1;
18422             }
18423         } // getOperandSize
18424
18425         bool
18426         isSrcOperand(int opIdx) override
18427         {
18428             switch (opIdx) {
18429               case 0: //src
18430                 return true;
18431               case 1: //vdst
18432                 return false;
18433               default:
18434                 fatal("op idx %i out of bounds\n", opIdx);
18435                 return false;
18436             }
18437         } // isSrcOperand
18438
18439         bool
18440         isDstOperand(int opIdx) override
18441         {
18442             switch (opIdx) {
18443               case 0: //src
18444                 return false;
18445               case 1: //vdst
18446                 return true;
18447               default:
18448                 fatal("op idx %i out of bounds\n", opIdx);
18449                 return false;
18450             }
18451         } // isDstOperand
18452
18453         void execute(GPUDynInstPtr) override;
18454     }; // Inst_VOP1__V_CVT_I16_F16
18455
18456     class Inst_VOP1__V_RCP_F16 : public Inst_VOP1
18457     {
18458       public:
18459         Inst_VOP1__V_RCP_F16(InFmt_VOP1*);
18460         ~Inst_VOP1__V_RCP_F16();
18461
18462         int
18463         getNumOperands() override
18464         {
18465             return numDstRegOperands() + numSrcRegOperands();
18466         } // getNumOperands
18467
18468         int numDstRegOperands() override { return 1; }
18469         int numSrcRegOperands() override { return 1; }
18470
18471         int
18472         getOperandSize(int opIdx) override
18473         {
18474             switch (opIdx) {
18475               case 0: //src
18476                 return 2;
18477               case 1: //vdst
18478                 return 2;
18479               default:
18480                 fatal("op idx %i out of bounds\n", opIdx);
18481                 return -1;
18482             }
18483         } // getOperandSize
18484
18485         bool
18486         isSrcOperand(int opIdx) override
18487         {
18488             switch (opIdx) {
18489               case 0: //src
18490                 return true;
18491               case 1: //vdst
18492                 return false;
18493               default:
18494                 fatal("op idx %i out of bounds\n", opIdx);
18495                 return false;
18496             }
18497         } // isSrcOperand
18498
18499         bool
18500         isDstOperand(int opIdx) override
18501         {
18502             switch (opIdx) {
18503               case 0: //src
18504                 return false;
18505               case 1: //vdst
18506                 return true;
18507               default:
18508                 fatal("op idx %i out of bounds\n", opIdx);
18509                 return false;
18510             }
18511         } // isDstOperand
18512
18513         void execute(GPUDynInstPtr) override;
18514     }; // Inst_VOP1__V_RCP_F16
18515
18516     class Inst_VOP1__V_SQRT_F16 : public Inst_VOP1
18517     {
18518       public:
18519         Inst_VOP1__V_SQRT_F16(InFmt_VOP1*);
18520         ~Inst_VOP1__V_SQRT_F16();
18521
18522         int
18523         getNumOperands() override
18524         {
18525             return numDstRegOperands() + numSrcRegOperands();
18526         } // getNumOperands
18527
18528         int numDstRegOperands() override { return 1; }
18529         int numSrcRegOperands() override { return 1; }
18530
18531         int
18532         getOperandSize(int opIdx) override
18533         {
18534             switch (opIdx) {
18535               case 0: //src
18536                 return 2;
18537               case 1: //vdst
18538                 return 2;
18539               default:
18540                 fatal("op idx %i out of bounds\n", opIdx);
18541                 return -1;
18542             }
18543         } // getOperandSize
18544
18545         bool
18546         isSrcOperand(int opIdx) override
18547         {
18548             switch (opIdx) {
18549               case 0: //src
18550                 return true;
18551               case 1: //vdst
18552                 return false;
18553               default:
18554                 fatal("op idx %i out of bounds\n", opIdx);
18555                 return false;
18556             }
18557         } // isSrcOperand
18558
18559         bool
18560         isDstOperand(int opIdx) override
18561         {
18562             switch (opIdx) {
18563               case 0: //src
18564                 return false;
18565               case 1: //vdst
18566                 return true;
18567               default:
18568                 fatal("op idx %i out of bounds\n", opIdx);
18569                 return false;
18570             }
18571         } // isDstOperand
18572
18573         void execute(GPUDynInstPtr) override;
18574     }; // Inst_VOP1__V_SQRT_F16
18575
18576     class Inst_VOP1__V_RSQ_F16 : public Inst_VOP1
18577     {
18578       public:
18579         Inst_VOP1__V_RSQ_F16(InFmt_VOP1*);
18580         ~Inst_VOP1__V_RSQ_F16();
18581
18582         int
18583         getNumOperands() override
18584         {
18585             return numDstRegOperands() + numSrcRegOperands();
18586         } // getNumOperands
18587
18588         int numDstRegOperands() override { return 1; }
18589         int numSrcRegOperands() override { return 1; }
18590
18591         int
18592         getOperandSize(int opIdx) override
18593         {
18594             switch (opIdx) {
18595               case 0: //src
18596                 return 2;
18597               case 1: //vdst
18598                 return 2;
18599               default:
18600                 fatal("op idx %i out of bounds\n", opIdx);
18601                 return -1;
18602             }
18603         } // getOperandSize
18604
18605         bool
18606         isSrcOperand(int opIdx) override
18607         {
18608             switch (opIdx) {
18609               case 0: //src
18610                 return true;
18611               case 1: //vdst
18612                 return false;
18613               default:
18614                 fatal("op idx %i out of bounds\n", opIdx);
18615                 return false;
18616             }
18617         } // isSrcOperand
18618
18619         bool
18620         isDstOperand(int opIdx) override
18621         {
18622             switch (opIdx) {
18623               case 0: //src
18624                 return false;
18625               case 1: //vdst
18626                 return true;
18627               default:
18628                 fatal("op idx %i out of bounds\n", opIdx);
18629                 return false;
18630             }
18631         } // isDstOperand
18632
18633         void execute(GPUDynInstPtr) override;
18634     }; // Inst_VOP1__V_RSQ_F16
18635
18636     class Inst_VOP1__V_LOG_F16 : public Inst_VOP1
18637     {
18638       public:
18639         Inst_VOP1__V_LOG_F16(InFmt_VOP1*);
18640         ~Inst_VOP1__V_LOG_F16();
18641
18642         int
18643         getNumOperands() override
18644         {
18645             return numDstRegOperands() + numSrcRegOperands();
18646         } // getNumOperands
18647
18648         int numDstRegOperands() override { return 1; }
18649         int numSrcRegOperands() override { return 1; }
18650
18651         int
18652         getOperandSize(int opIdx) override
18653         {
18654             switch (opIdx) {
18655               case 0: //src
18656                 return 2;
18657               case 1: //vdst
18658                 return 2;
18659               default:
18660                 fatal("op idx %i out of bounds\n", opIdx);
18661                 return -1;
18662             }
18663         } // getOperandSize
18664
18665         bool
18666         isSrcOperand(int opIdx) override
18667         {
18668             switch (opIdx) {
18669               case 0: //src
18670                 return true;
18671               case 1: //vdst
18672                 return false;
18673               default:
18674                 fatal("op idx %i out of bounds\n", opIdx);
18675                 return false;
18676             }
18677         } // isSrcOperand
18678
18679         bool
18680         isDstOperand(int opIdx) override
18681         {
18682             switch (opIdx) {
18683               case 0: //src
18684                 return false;
18685               case 1: //vdst
18686                 return true;
18687               default:
18688                 fatal("op idx %i out of bounds\n", opIdx);
18689                 return false;
18690             }
18691         } // isDstOperand
18692
18693         void execute(GPUDynInstPtr) override;
18694     }; // Inst_VOP1__V_LOG_F16
18695
18696     class Inst_VOP1__V_EXP_F16 : public Inst_VOP1
18697     {
18698       public:
18699         Inst_VOP1__V_EXP_F16(InFmt_VOP1*);
18700         ~Inst_VOP1__V_EXP_F16();
18701
18702         int
18703         getNumOperands() override
18704         {
18705             return numDstRegOperands() + numSrcRegOperands();
18706         } // getNumOperands
18707
18708         int numDstRegOperands() override { return 1; }
18709         int numSrcRegOperands() override { return 1; }
18710
18711         int
18712         getOperandSize(int opIdx) override
18713         {
18714             switch (opIdx) {
18715               case 0: //src
18716                 return 2;
18717               case 1: //vdst
18718                 return 2;
18719               default:
18720                 fatal("op idx %i out of bounds\n", opIdx);
18721                 return -1;
18722             }
18723         } // getOperandSize
18724
18725         bool
18726         isSrcOperand(int opIdx) override
18727         {
18728             switch (opIdx) {
18729               case 0: //src
18730                 return true;
18731               case 1: //vdst
18732                 return false;
18733               default:
18734                 fatal("op idx %i out of bounds\n", opIdx);
18735                 return false;
18736             }
18737         } // isSrcOperand
18738
18739         bool
18740         isDstOperand(int opIdx) override
18741         {
18742             switch (opIdx) {
18743               case 0: //src
18744                 return false;
18745               case 1: //vdst
18746                 return true;
18747               default:
18748                 fatal("op idx %i out of bounds\n", opIdx);
18749                 return false;
18750             }
18751         } // isDstOperand
18752
18753         void execute(GPUDynInstPtr) override;
18754     }; // Inst_VOP1__V_EXP_F16
18755
18756     class Inst_VOP1__V_FREXP_MANT_F16 : public Inst_VOP1
18757     {
18758       public:
18759         Inst_VOP1__V_FREXP_MANT_F16(InFmt_VOP1*);
18760         ~Inst_VOP1__V_FREXP_MANT_F16();
18761
18762         int
18763         getNumOperands() override
18764         {
18765             return numDstRegOperands() + numSrcRegOperands();
18766         } // getNumOperands
18767
18768         int numDstRegOperands() override { return 1; }
18769         int numSrcRegOperands() override { return 1; }
18770
18771         int
18772         getOperandSize(int opIdx) override
18773         {
18774             switch (opIdx) {
18775               case 0: //src
18776                 return 2;
18777               case 1: //vdst
18778                 return 2;
18779               default:
18780                 fatal("op idx %i out of bounds\n", opIdx);
18781                 return -1;
18782             }
18783         } // getOperandSize
18784
18785         bool
18786         isSrcOperand(int opIdx) override
18787         {
18788             switch (opIdx) {
18789               case 0: //src
18790                 return true;
18791               case 1: //vdst
18792                 return false;
18793               default:
18794                 fatal("op idx %i out of bounds\n", opIdx);
18795                 return false;
18796             }
18797         } // isSrcOperand
18798
18799         bool
18800         isDstOperand(int opIdx) override
18801         {
18802             switch (opIdx) {
18803               case 0: //src
18804                 return false;
18805               case 1: //vdst
18806                 return true;
18807               default:
18808                 fatal("op idx %i out of bounds\n", opIdx);
18809                 return false;
18810             }
18811         } // isDstOperand
18812
18813         void execute(GPUDynInstPtr) override;
18814     }; // Inst_VOP1__V_FREXP_MANT_F16
18815
18816     class Inst_VOP1__V_FREXP_EXP_I16_F16 : public Inst_VOP1
18817     {
18818       public:
18819         Inst_VOP1__V_FREXP_EXP_I16_F16(InFmt_VOP1*);
18820         ~Inst_VOP1__V_FREXP_EXP_I16_F16();
18821
18822         int
18823         getNumOperands() override
18824         {
18825             return numDstRegOperands() + numSrcRegOperands();
18826         } // getNumOperands
18827
18828         int numDstRegOperands() override { return 1; }
18829         int numSrcRegOperands() override { return 1; }
18830
18831         int
18832         getOperandSize(int opIdx) override
18833         {
18834             switch (opIdx) {
18835               case 0: //src
18836                 return 2;
18837               case 1: //vdst
18838                 return 2;
18839               default:
18840                 fatal("op idx %i out of bounds\n", opIdx);
18841                 return -1;
18842             }
18843         } // getOperandSize
18844
18845         bool
18846         isSrcOperand(int opIdx) override
18847         {
18848             switch (opIdx) {
18849               case 0: //src
18850                 return true;
18851               case 1: //vdst
18852                 return false;
18853               default:
18854                 fatal("op idx %i out of bounds\n", opIdx);
18855                 return false;
18856             }
18857         } // isSrcOperand
18858
18859         bool
18860         isDstOperand(int opIdx) override
18861         {
18862             switch (opIdx) {
18863               case 0: //src
18864                 return false;
18865               case 1: //vdst
18866                 return true;
18867               default:
18868                 fatal("op idx %i out of bounds\n", opIdx);
18869                 return false;
18870             }
18871         } // isDstOperand
18872
18873         void execute(GPUDynInstPtr) override;
18874     }; // Inst_VOP1__V_FREXP_EXP_I16_F16
18875
18876     class Inst_VOP1__V_FLOOR_F16 : public Inst_VOP1
18877     {
18878       public:
18879         Inst_VOP1__V_FLOOR_F16(InFmt_VOP1*);
18880         ~Inst_VOP1__V_FLOOR_F16();
18881
18882         int
18883         getNumOperands() override
18884         {
18885             return numDstRegOperands() + numSrcRegOperands();
18886         } // getNumOperands
18887
18888         int numDstRegOperands() override { return 1; }
18889         int numSrcRegOperands() override { return 1; }
18890
18891         int
18892         getOperandSize(int opIdx) override
18893         {
18894             switch (opIdx) {
18895               case 0: //src
18896                 return 2;
18897               case 1: //vdst
18898                 return 2;
18899               default:
18900                 fatal("op idx %i out of bounds\n", opIdx);
18901                 return -1;
18902             }
18903         } // getOperandSize
18904
18905         bool
18906         isSrcOperand(int opIdx) override
18907         {
18908             switch (opIdx) {
18909               case 0: //src
18910                 return true;
18911               case 1: //vdst
18912                 return false;
18913               default:
18914                 fatal("op idx %i out of bounds\n", opIdx);
18915                 return false;
18916             }
18917         } // isSrcOperand
18918
18919         bool
18920         isDstOperand(int opIdx) override
18921         {
18922             switch (opIdx) {
18923               case 0: //src
18924                 return false;
18925               case 1: //vdst
18926                 return true;
18927               default:
18928                 fatal("op idx %i out of bounds\n", opIdx);
18929                 return false;
18930             }
18931         } // isDstOperand
18932
18933         void execute(GPUDynInstPtr) override;
18934     }; // Inst_VOP1__V_FLOOR_F16
18935
18936     class Inst_VOP1__V_CEIL_F16 : public Inst_VOP1
18937     {
18938       public:
18939         Inst_VOP1__V_CEIL_F16(InFmt_VOP1*);
18940         ~Inst_VOP1__V_CEIL_F16();
18941
18942         int
18943         getNumOperands() override
18944         {
18945             return numDstRegOperands() + numSrcRegOperands();
18946         } // getNumOperands
18947
18948         int numDstRegOperands() override { return 1; }
18949         int numSrcRegOperands() override { return 1; }
18950
18951         int
18952         getOperandSize(int opIdx) override
18953         {
18954             switch (opIdx) {
18955               case 0: //src
18956                 return 2;
18957               case 1: //vdst
18958                 return 2;
18959               default:
18960                 fatal("op idx %i out of bounds\n", opIdx);
18961                 return -1;
18962             }
18963         } // getOperandSize
18964
18965         bool
18966         isSrcOperand(int opIdx) override
18967         {
18968             switch (opIdx) {
18969               case 0: //src
18970                 return true;
18971               case 1: //vdst
18972                 return false;
18973               default:
18974                 fatal("op idx %i out of bounds\n", opIdx);
18975                 return false;
18976             }
18977         } // isSrcOperand
18978
18979         bool
18980         isDstOperand(int opIdx) override
18981         {
18982             switch (opIdx) {
18983               case 0: //src
18984                 return false;
18985               case 1: //vdst
18986                 return true;
18987               default:
18988                 fatal("op idx %i out of bounds\n", opIdx);
18989                 return false;
18990             }
18991         } // isDstOperand
18992
18993         void execute(GPUDynInstPtr) override;
18994     }; // Inst_VOP1__V_CEIL_F16
18995
18996     class Inst_VOP1__V_TRUNC_F16 : public Inst_VOP1
18997     {
18998       public:
18999         Inst_VOP1__V_TRUNC_F16(InFmt_VOP1*);
19000         ~Inst_VOP1__V_TRUNC_F16();
19001
19002         int
19003         getNumOperands() override
19004         {
19005             return numDstRegOperands() + numSrcRegOperands();
19006         } // getNumOperands
19007
19008         int numDstRegOperands() override { return 1; }
19009         int numSrcRegOperands() override { return 1; }
19010
19011         int
19012         getOperandSize(int opIdx) override
19013         {
19014             switch (opIdx) {
19015               case 0: //src
19016                 return 2;
19017               case 1: //vdst
19018                 return 2;
19019               default:
19020                 fatal("op idx %i out of bounds\n", opIdx);
19021                 return -1;
19022             }
19023         } // getOperandSize
19024
19025         bool
19026         isSrcOperand(int opIdx) override
19027         {
19028             switch (opIdx) {
19029               case 0: //src
19030                 return true;
19031               case 1: //vdst
19032                 return false;
19033               default:
19034                 fatal("op idx %i out of bounds\n", opIdx);
19035                 return false;
19036             }
19037         } // isSrcOperand
19038
19039         bool
19040         isDstOperand(int opIdx) override
19041         {
19042             switch (opIdx) {
19043               case 0: //src
19044                 return false;
19045               case 1: //vdst
19046                 return true;
19047               default:
19048                 fatal("op idx %i out of bounds\n", opIdx);
19049                 return false;
19050             }
19051         } // isDstOperand
19052
19053         void execute(GPUDynInstPtr) override;
19054     }; // Inst_VOP1__V_TRUNC_F16
19055
19056     class Inst_VOP1__V_RNDNE_F16 : public Inst_VOP1
19057     {
19058       public:
19059         Inst_VOP1__V_RNDNE_F16(InFmt_VOP1*);
19060         ~Inst_VOP1__V_RNDNE_F16();
19061
19062         int
19063         getNumOperands() override
19064         {
19065             return numDstRegOperands() + numSrcRegOperands();
19066         } // getNumOperands
19067
19068         int numDstRegOperands() override { return 1; }
19069         int numSrcRegOperands() override { return 1; }
19070
19071         int
19072         getOperandSize(int opIdx) override
19073         {
19074             switch (opIdx) {
19075               case 0: //src
19076                 return 2;
19077               case 1: //vdst
19078                 return 2;
19079               default:
19080                 fatal("op idx %i out of bounds\n", opIdx);
19081                 return -1;
19082             }
19083         } // getOperandSize
19084
19085         bool
19086         isSrcOperand(int opIdx) override
19087         {
19088             switch (opIdx) {
19089               case 0: //src
19090                 return true;
19091               case 1: //vdst
19092                 return false;
19093               default:
19094                 fatal("op idx %i out of bounds\n", opIdx);
19095                 return false;
19096             }
19097         } // isSrcOperand
19098
19099         bool
19100         isDstOperand(int opIdx) override
19101         {
19102             switch (opIdx) {
19103               case 0: //src
19104                 return false;
19105               case 1: //vdst
19106                 return true;
19107               default:
19108                 fatal("op idx %i out of bounds\n", opIdx);
19109                 return false;
19110             }
19111         } // isDstOperand
19112
19113         void execute(GPUDynInstPtr) override;
19114     }; // Inst_VOP1__V_RNDNE_F16
19115
19116     class Inst_VOP1__V_FRACT_F16 : public Inst_VOP1
19117     {
19118       public:
19119         Inst_VOP1__V_FRACT_F16(InFmt_VOP1*);
19120         ~Inst_VOP1__V_FRACT_F16();
19121
19122         int
19123         getNumOperands() override
19124         {
19125             return numDstRegOperands() + numSrcRegOperands();
19126         } // getNumOperands
19127
19128         int numDstRegOperands() override { return 1; }
19129         int numSrcRegOperands() override { return 1; }
19130
19131         int
19132         getOperandSize(int opIdx) override
19133         {
19134             switch (opIdx) {
19135               case 0: //src
19136                 return 2;
19137               case 1: //vdst
19138                 return 2;
19139               default:
19140                 fatal("op idx %i out of bounds\n", opIdx);
19141                 return -1;
19142             }
19143         } // getOperandSize
19144
19145         bool
19146         isSrcOperand(int opIdx) override
19147         {
19148             switch (opIdx) {
19149               case 0: //src
19150                 return true;
19151               case 1: //vdst
19152                 return false;
19153               default:
19154                 fatal("op idx %i out of bounds\n", opIdx);
19155                 return false;
19156             }
19157         } // isSrcOperand
19158
19159         bool
19160         isDstOperand(int opIdx) override
19161         {
19162             switch (opIdx) {
19163               case 0: //src
19164                 return false;
19165               case 1: //vdst
19166                 return true;
19167               default:
19168                 fatal("op idx %i out of bounds\n", opIdx);
19169                 return false;
19170             }
19171         } // isDstOperand
19172
19173         void execute(GPUDynInstPtr) override;
19174     }; // Inst_VOP1__V_FRACT_F16
19175
19176     class Inst_VOP1__V_SIN_F16 : public Inst_VOP1
19177     {
19178       public:
19179         Inst_VOP1__V_SIN_F16(InFmt_VOP1*);
19180         ~Inst_VOP1__V_SIN_F16();
19181
19182         int
19183         getNumOperands() override
19184         {
19185             return numDstRegOperands() + numSrcRegOperands();
19186         } // getNumOperands
19187
19188         int numDstRegOperands() override { return 1; }
19189         int numSrcRegOperands() override { return 1; }
19190
19191         int
19192         getOperandSize(int opIdx) override
19193         {
19194             switch (opIdx) {
19195               case 0: //src
19196                 return 2;
19197               case 1: //vdst
19198                 return 2;
19199               default:
19200                 fatal("op idx %i out of bounds\n", opIdx);
19201                 return -1;
19202             }
19203         } // getOperandSize
19204
19205         bool
19206         isSrcOperand(int opIdx) override
19207         {
19208             switch (opIdx) {
19209               case 0: //src
19210                 return true;
19211               case 1: //vdst
19212                 return false;
19213               default:
19214                 fatal("op idx %i out of bounds\n", opIdx);
19215                 return false;
19216             }
19217         } // isSrcOperand
19218
19219         bool
19220         isDstOperand(int opIdx) override
19221         {
19222             switch (opIdx) {
19223               case 0: //src
19224                 return false;
19225               case 1: //vdst
19226                 return true;
19227               default:
19228                 fatal("op idx %i out of bounds\n", opIdx);
19229                 return false;
19230             }
19231         } // isDstOperand
19232
19233         void execute(GPUDynInstPtr) override;
19234     }; // Inst_VOP1__V_SIN_F16
19235
19236     class Inst_VOP1__V_COS_F16 : public Inst_VOP1
19237     {
19238       public:
19239         Inst_VOP1__V_COS_F16(InFmt_VOP1*);
19240         ~Inst_VOP1__V_COS_F16();
19241
19242         int
19243         getNumOperands() override
19244         {
19245             return numDstRegOperands() + numSrcRegOperands();
19246         } // getNumOperands
19247
19248         int numDstRegOperands() override { return 1; }
19249         int numSrcRegOperands() override { return 1; }
19250
19251         int
19252         getOperandSize(int opIdx) override
19253         {
19254             switch (opIdx) {
19255               case 0: //src
19256                 return 2;
19257               case 1: //vdst
19258                 return 2;
19259               default:
19260                 fatal("op idx %i out of bounds\n", opIdx);
19261                 return -1;
19262             }
19263         } // getOperandSize
19264
19265         bool
19266         isSrcOperand(int opIdx) override
19267         {
19268             switch (opIdx) {
19269               case 0: //src
19270                 return true;
19271               case 1: //vdst
19272                 return false;
19273               default:
19274                 fatal("op idx %i out of bounds\n", opIdx);
19275                 return false;
19276             }
19277         } // isSrcOperand
19278
19279         bool
19280         isDstOperand(int opIdx) override
19281         {
19282             switch (opIdx) {
19283               case 0: //src
19284                 return false;
19285               case 1: //vdst
19286                 return true;
19287               default:
19288                 fatal("op idx %i out of bounds\n", opIdx);
19289                 return false;
19290             }
19291         } // isDstOperand
19292
19293         void execute(GPUDynInstPtr) override;
19294     }; // Inst_VOP1__V_COS_F16
19295
19296     class Inst_VOP1__V_EXP_LEGACY_F32 : public Inst_VOP1
19297     {
19298       public:
19299         Inst_VOP1__V_EXP_LEGACY_F32(InFmt_VOP1*);
19300         ~Inst_VOP1__V_EXP_LEGACY_F32();
19301
19302         int
19303         getNumOperands() override
19304         {
19305             return numDstRegOperands() + numSrcRegOperands();
19306         } // getNumOperands
19307
19308         int numDstRegOperands() override { return 1; }
19309         int numSrcRegOperands() override { return 1; }
19310
19311         int
19312         getOperandSize(int opIdx) override
19313         {
19314             switch (opIdx) {
19315               case 0: //src
19316                 return 4;
19317               case 1: //vdst
19318                 return 4;
19319               default:
19320                 fatal("op idx %i out of bounds\n", opIdx);
19321                 return -1;
19322             }
19323         } // getOperandSize
19324
19325         bool
19326         isSrcOperand(int opIdx) override
19327         {
19328             switch (opIdx) {
19329               case 0: //src
19330                 return true;
19331               case 1: //vdst
19332                 return false;
19333               default:
19334                 fatal("op idx %i out of bounds\n", opIdx);
19335                 return false;
19336             }
19337         } // isSrcOperand
19338
19339         bool
19340         isDstOperand(int opIdx) override
19341         {
19342             switch (opIdx) {
19343               case 0: //src
19344                 return false;
19345               case 1: //vdst
19346                 return true;
19347               default:
19348                 fatal("op idx %i out of bounds\n", opIdx);
19349                 return false;
19350             }
19351         } // isDstOperand
19352
19353         void execute(GPUDynInstPtr) override;
19354     }; // Inst_VOP1__V_EXP_LEGACY_F32
19355
19356     class Inst_VOP1__V_LOG_LEGACY_F32 : public Inst_VOP1
19357     {
19358       public:
19359         Inst_VOP1__V_LOG_LEGACY_F32(InFmt_VOP1*);
19360         ~Inst_VOP1__V_LOG_LEGACY_F32();
19361
19362         int
19363         getNumOperands() override
19364         {
19365             return numDstRegOperands() + numSrcRegOperands();
19366         } // getNumOperands
19367
19368         int numDstRegOperands() override { return 1; }
19369         int numSrcRegOperands() override { return 1; }
19370
19371         int
19372         getOperandSize(int opIdx) override
19373         {
19374             switch (opIdx) {
19375               case 0: //src
19376                 return 4;
19377               case 1: //vdst
19378                 return 4;
19379               default:
19380                 fatal("op idx %i out of bounds\n", opIdx);
19381                 return -1;
19382             }
19383         } // getOperandSize
19384
19385         bool
19386         isSrcOperand(int opIdx) override
19387         {
19388             switch (opIdx) {
19389               case 0: //src
19390                 return true;
19391               case 1: //vdst
19392                 return false;
19393               default:
19394                 fatal("op idx %i out of bounds\n", opIdx);
19395                 return false;
19396             }
19397         } // isSrcOperand
19398
19399         bool
19400         isDstOperand(int opIdx) override
19401         {
19402             switch (opIdx) {
19403               case 0: //src
19404                 return false;
19405               case 1: //vdst
19406                 return true;
19407               default:
19408                 fatal("op idx %i out of bounds\n", opIdx);
19409                 return false;
19410             }
19411         } // isDstOperand
19412
19413         void execute(GPUDynInstPtr) override;
19414     }; // Inst_VOP1__V_LOG_LEGACY_F32
19415
19416     class Inst_VOPC__V_CMP_CLASS_F32 : public Inst_VOPC
19417     {
19418       public:
19419         Inst_VOPC__V_CMP_CLASS_F32(InFmt_VOPC*);
19420         ~Inst_VOPC__V_CMP_CLASS_F32();
19421
19422         int
19423         getNumOperands() override
19424         {
19425             return numDstRegOperands() + numSrcRegOperands();
19426         } // getNumOperands
19427
19428         int numDstRegOperands() override { return 1; }
19429         int numSrcRegOperands() override { return 2; }
19430
19431         int
19432         getOperandSize(int opIdx) override
19433         {
19434             switch (opIdx) {
19435               case 0: //src_0
19436                 return 4;
19437               case 1: //src_1
19438                 return 4;
19439               case 2: //vcc
19440                 return 8;
19441               default:
19442                 fatal("op idx %i out of bounds\n", opIdx);
19443                 return -1;
19444             }
19445         } // getOperandSize
19446
19447         bool
19448         isSrcOperand(int opIdx) override
19449         {
19450             switch (opIdx) {
19451               case 0: //src_0
19452                 return true;
19453               case 1: //src_1
19454                 return true;
19455               case 2: //vcc
19456                 return false;
19457               default:
19458                 fatal("op idx %i out of bounds\n", opIdx);
19459                 return false;
19460             }
19461         } // isSrcOperand
19462
19463         bool
19464         isDstOperand(int opIdx) override
19465         {
19466             switch (opIdx) {
19467               case 0: //src_0
19468                 return false;
19469               case 1: //src_1
19470                 return false;
19471               case 2: //vcc
19472                 return true;
19473               default:
19474                 fatal("op idx %i out of bounds\n", opIdx);
19475                 return false;
19476             }
19477         } // isDstOperand
19478
19479         void execute(GPUDynInstPtr) override;
19480     }; // Inst_VOPC__V_CMP_CLASS_F32
19481
19482     class Inst_VOPC__V_CMPX_CLASS_F32 : public Inst_VOPC
19483     {
19484       public:
19485         Inst_VOPC__V_CMPX_CLASS_F32(InFmt_VOPC*);
19486         ~Inst_VOPC__V_CMPX_CLASS_F32();
19487
19488         int
19489         getNumOperands() override
19490         {
19491             return numDstRegOperands() + numSrcRegOperands();
19492         } // getNumOperands
19493
19494         int numDstRegOperands() override { return 1; }
19495         int numSrcRegOperands() override { return 2; }
19496
19497         int
19498         getOperandSize(int opIdx) override
19499         {
19500             switch (opIdx) {
19501               case 0: //src_0
19502                 return 4;
19503               case 1: //src_1
19504                 return 4;
19505               case 2: //vcc
19506                 return 8;
19507               default:
19508                 fatal("op idx %i out of bounds\n", opIdx);
19509                 return -1;
19510             }
19511         } // getOperandSize
19512
19513         bool
19514         isSrcOperand(int opIdx) override
19515         {
19516             switch (opIdx) {
19517               case 0: //src_0
19518                 return true;
19519               case 1: //src_1
19520                 return true;
19521               default:
19522                 fatal("op idx %i out of bounds\n", opIdx);
19523                 return false;
19524             }
19525         } // isSrcOperand
19526
19527         bool
19528         isDstOperand(int opIdx) override
19529         {
19530             switch (opIdx) {
19531               case 0: //src_0
19532                 return false;
19533               case 1: //src_1
19534                 return false;
19535               default:
19536                 fatal("op idx %i out of bounds\n", opIdx);
19537                 return false;
19538             }
19539         } // isDstOperand
19540
19541         void execute(GPUDynInstPtr) override;
19542     }; // Inst_VOPC__V_CMPX_CLASS_F32
19543
19544     class Inst_VOPC__V_CMP_CLASS_F64 : public Inst_VOPC
19545     {
19546       public:
19547         Inst_VOPC__V_CMP_CLASS_F64(InFmt_VOPC*);
19548         ~Inst_VOPC__V_CMP_CLASS_F64();
19549
19550         int
19551         getNumOperands() override
19552         {
19553             return numDstRegOperands() + numSrcRegOperands();
19554         } // getNumOperands
19555
19556         int numDstRegOperands() override { return 1; }
19557         int numSrcRegOperands() override { return 2; }
19558
19559         int
19560         getOperandSize(int opIdx) override
19561         {
19562             switch (opIdx) {
19563               case 0: //src_0
19564                 return 8;
19565               case 1: //src_1
19566                 return 4;
19567               case 2: //vcc
19568                 return 8;
19569               default:
19570                 fatal("op idx %i out of bounds\n", opIdx);
19571                 return -1;
19572             }
19573         } // getOperandSize
19574
19575         bool
19576         isSrcOperand(int opIdx) override
19577         {
19578             switch (opIdx) {
19579               case 0: //src_0
19580                 return true;
19581               case 1: //src_1
19582                 return true;
19583               case 2: //vcc
19584                 return false;
19585               default:
19586                 fatal("op idx %i out of bounds\n", opIdx);
19587                 return false;
19588             }
19589         } // isSrcOperand
19590
19591         bool
19592         isDstOperand(int opIdx) override
19593         {
19594             switch (opIdx) {
19595               case 0: //src_0
19596                 return false;
19597               case 1: //src_1
19598                 return false;
19599               case 2: // vcc
19600                 return true;
19601               default:
19602                 fatal("op idx %i out of bounds\n", opIdx);
19603                 return false;
19604             }
19605         } // isDstOperand
19606
19607         void execute(GPUDynInstPtr) override;
19608     }; // Inst_VOPC__V_CMP_CLASS_F64
19609
19610     class Inst_VOPC__V_CMPX_CLASS_F64 : public Inst_VOPC
19611     {
19612       public:
19613         Inst_VOPC__V_CMPX_CLASS_F64(InFmt_VOPC*);
19614         ~Inst_VOPC__V_CMPX_CLASS_F64();
19615
19616         int
19617         getNumOperands() override
19618         {
19619             return numDstRegOperands() + numSrcRegOperands();
19620         } // getNumOperands
19621
19622         int numDstRegOperands() override { return 1; }
19623         int numSrcRegOperands() override { return 2; }
19624
19625         int
19626         getOperandSize(int opIdx) override
19627         {
19628             switch (opIdx) {
19629               case 0: //src_0
19630                 return 8;
19631               case 1: //src_1
19632                 return 4;
19633               case 2: //vcc
19634                 return 8;
19635               default:
19636                 fatal("op idx %i out of bounds\n", opIdx);
19637                 return -1;
19638             }
19639         } // getOperandSize
19640
19641         bool
19642         isSrcOperand(int opIdx) override
19643         {
19644             switch (opIdx) {
19645               case 0: //src_0
19646                 return true;
19647               case 1: //src_1
19648                 return true;
19649               default:
19650                 fatal("op idx %i out of bounds\n", opIdx);
19651                 return false;
19652             }
19653         } // isSrcOperand
19654
19655         bool
19656         isDstOperand(int opIdx) override
19657         {
19658             switch (opIdx) {
19659               case 0: //src_0
19660                 return false;
19661               case 1: //src_1
19662                 return false;
19663               default:
19664                 fatal("op idx %i out of bounds\n", opIdx);
19665                 return false;
19666             }
19667         } // isDstOperand
19668
19669         void execute(GPUDynInstPtr) override;
19670     }; // Inst_VOPC__V_CMPX_CLASS_F64
19671
19672     class Inst_VOPC__V_CMP_CLASS_F16 : public Inst_VOPC
19673     {
19674       public:
19675         Inst_VOPC__V_CMP_CLASS_F16(InFmt_VOPC*);
19676         ~Inst_VOPC__V_CMP_CLASS_F16();
19677
19678         int
19679         getNumOperands() override
19680         {
19681             return numDstRegOperands() + numSrcRegOperands();
19682         } // getNumOperands
19683
19684         int numDstRegOperands() override { return 1; }
19685         int numSrcRegOperands() override { return 2; }
19686
19687         int
19688         getOperandSize(int opIdx) override
19689         {
19690             switch (opIdx) {
19691               case 0: //src_0
19692                 return 2;
19693               case 1: //src_1
19694                 return 2;
19695               case 2: //vcc
19696                 return 8;
19697               default:
19698                 fatal("op idx %i out of bounds\n", opIdx);
19699                 return -1;
19700             }
19701         } // getOperandSize
19702
19703         bool
19704         isSrcOperand(int opIdx) override
19705         {
19706             switch (opIdx) {
19707               case 0: //src_0
19708                 return true;
19709               case 1: //src_1
19710                 return true;
19711               default:
19712                 fatal("op idx %i out of bounds\n", opIdx);
19713                 return false;
19714             }
19715         } // isSrcOperand
19716
19717         bool
19718         isDstOperand(int opIdx) override
19719         {
19720             switch (opIdx) {
19721               case 0: //src_0
19722                 return false;
19723               case 1: //src_1
19724                 return false;
19725               default:
19726                 fatal("op idx %i out of bounds\n", opIdx);
19727                 return false;
19728             }
19729         } // isDstOperand
19730
19731         void execute(GPUDynInstPtr) override;
19732     }; // Inst_VOPC__V_CMP_CLASS_F16
19733
19734     class Inst_VOPC__V_CMPX_CLASS_F16 : public Inst_VOPC
19735     {
19736       public:
19737         Inst_VOPC__V_CMPX_CLASS_F16(InFmt_VOPC*);
19738         ~Inst_VOPC__V_CMPX_CLASS_F16();
19739
19740         int
19741         getNumOperands() override
19742         {
19743             return numDstRegOperands() + numSrcRegOperands();
19744         } // getNumOperands
19745
19746         int numDstRegOperands() override { return 1; }
19747         int numSrcRegOperands() override { return 2; }
19748
19749         int
19750         getOperandSize(int opIdx) override
19751         {
19752             switch (opIdx) {
19753               case 0: //src_0
19754                 return 2;
19755               case 1: //src_1
19756                 return 2;
19757               case 2: //vcc
19758                 return 8;
19759               default:
19760                 fatal("op idx %i out of bounds\n", opIdx);
19761                 return -1;
19762             }
19763         } // getOperandSize
19764
19765         bool
19766         isSrcOperand(int opIdx) override
19767         {
19768             switch (opIdx) {
19769               case 0: //src_0
19770                 return true;
19771               case 1: //src_1
19772                 return true;
19773               default:
19774                 fatal("op idx %i out of bounds\n", opIdx);
19775                 return false;
19776             }
19777         } // isSrcOperand
19778
19779         bool
19780         isDstOperand(int opIdx) override
19781         {
19782             switch (opIdx) {
19783               case 0: //src_0
19784                 return false;
19785               case 1: //src_1
19786                 return false;
19787               default:
19788                 fatal("op idx %i out of bounds\n", opIdx);
19789                 return false;
19790             }
19791         } // isDstOperand
19792
19793         void execute(GPUDynInstPtr) override;
19794     }; // Inst_VOPC__V_CMPX_CLASS_F16
19795
19796     class Inst_VOPC__V_CMP_F_F16 : public Inst_VOPC
19797     {
19798       public:
19799         Inst_VOPC__V_CMP_F_F16(InFmt_VOPC*);
19800         ~Inst_VOPC__V_CMP_F_F16();
19801
19802         int
19803         getNumOperands() override
19804         {
19805             return numDstRegOperands() + numSrcRegOperands();
19806         } // getNumOperands
19807
19808         int numDstRegOperands() override { return 1; }
19809         int numSrcRegOperands() override { return 2; }
19810
19811         int
19812         getOperandSize(int opIdx) override
19813         {
19814             switch (opIdx) {
19815               case 0: //src_0
19816                 return 2;
19817               case 1: //src_1
19818                 return 2;
19819               case 2: //vcc
19820                 return 8;
19821               default:
19822                 fatal("op idx %i out of bounds\n", opIdx);
19823                 return -1;
19824             }
19825         } // getOperandSize
19826
19827         bool
19828         isSrcOperand(int opIdx) override
19829         {
19830             switch (opIdx) {
19831               case 0: //src_0
19832                 return true;
19833               case 1: //src_1
19834                 return true;
19835               case 2: //vcc
19836                 return false;
19837               default:
19838                 fatal("op idx %i out of bounds\n", opIdx);
19839                 return false;
19840             }
19841         } // isSrcOperand
19842
19843         bool
19844         isDstOperand(int opIdx) override
19845         {
19846             switch (opIdx) {
19847               case 0: //src_0
19848                 return false;
19849               case 1: //src_1
19850                 return false;
19851               case 2: //vcc
19852                 return true;
19853               default:
19854                 fatal("op idx %i out of bounds\n", opIdx);
19855                 return false;
19856             }
19857         } // isDstOperand
19858
19859         void execute(GPUDynInstPtr) override;
19860     }; // Inst_VOPC__V_CMP_F_F16
19861
19862     class Inst_VOPC__V_CMP_LT_F16 : public Inst_VOPC
19863     {
19864       public:
19865         Inst_VOPC__V_CMP_LT_F16(InFmt_VOPC*);
19866         ~Inst_VOPC__V_CMP_LT_F16();
19867
19868         int
19869         getNumOperands() override
19870         {
19871             return numDstRegOperands() + numSrcRegOperands();
19872         } // getNumOperands
19873
19874         int numDstRegOperands() override { return 1; }
19875         int numSrcRegOperands() override { return 2; }
19876
19877         int
19878         getOperandSize(int opIdx) override
19879         {
19880             switch (opIdx) {
19881               case 0: //src_0
19882                 return 2;
19883               case 1: //src_1
19884                 return 2;
19885               case 2: //vcc
19886                 return 8;
19887               default:
19888                 fatal("op idx %i out of bounds\n", opIdx);
19889                 return -1;
19890             }
19891         } // getOperandSize
19892
19893         bool
19894         isSrcOperand(int opIdx) override
19895         {
19896             switch (opIdx) {
19897               case 0: //src_0
19898                 return true;
19899               case 1: //src_1
19900                 return true;
19901               case 2: //vcc
19902                 return false;
19903               default:
19904                 fatal("op idx %i out of bounds\n", opIdx);
19905                 return false;
19906             }
19907         } // isSrcOperand
19908
19909         bool
19910         isDstOperand(int opIdx) override
19911         {
19912             switch (opIdx) {
19913               case 0: //src_0
19914                 return false;
19915               case 1: //src_1
19916                 return false;
19917               case 2: //vcc
19918                 return true;
19919               default:
19920                 fatal("op idx %i out of bounds\n", opIdx);
19921                 return false;
19922             }
19923         } // isDstOperand
19924
19925         void execute(GPUDynInstPtr) override;
19926     }; // Inst_VOPC__V_CMP_LT_F16
19927
19928     class Inst_VOPC__V_CMP_EQ_F16 : public Inst_VOPC
19929     {
19930       public:
19931         Inst_VOPC__V_CMP_EQ_F16(InFmt_VOPC*);
19932         ~Inst_VOPC__V_CMP_EQ_F16();
19933
19934         int
19935         getNumOperands() override
19936         {
19937             return numDstRegOperands() + numSrcRegOperands();
19938         } // getNumOperands
19939
19940         int numDstRegOperands() override { return 1; }
19941         int numSrcRegOperands() override { return 2; }
19942
19943         int
19944         getOperandSize(int opIdx) override
19945         {
19946             switch (opIdx) {
19947               case 0: //src_0
19948                 return 2;
19949               case 1: //src_1
19950                 return 2;
19951               case 2: //vcc
19952                 return 8;
19953               default:
19954                 fatal("op idx %i out of bounds\n", opIdx);
19955                 return -1;
19956             }
19957         } // getOperandSize
19958
19959         bool
19960         isSrcOperand(int opIdx) override
19961         {
19962             switch (opIdx) {
19963               case 0: //src_0
19964                 return true;
19965               case 1: //src_1
19966                 return true;
19967               case 2: //vcc
19968                 return false;
19969               default:
19970                 fatal("op idx %i out of bounds\n", opIdx);
19971                 return false;
19972             }
19973         } // isSrcOperand
19974
19975         bool
19976         isDstOperand(int opIdx) override
19977         {
19978             switch (opIdx) {
19979               case 0: //src_0
19980                 return false;
19981               case 1: //src_1
19982                 return false;
19983               case 2: //vcc
19984                 return true;
19985               default:
19986                 fatal("op idx %i out of bounds\n", opIdx);
19987                 return false;
19988             }
19989         } // isDstOperand
19990
19991         void execute(GPUDynInstPtr) override;
19992     }; // Inst_VOPC__V_CMP_EQ_F16
19993
19994     class Inst_VOPC__V_CMP_LE_F16 : public Inst_VOPC
19995     {
19996       public:
19997         Inst_VOPC__V_CMP_LE_F16(InFmt_VOPC*);
19998         ~Inst_VOPC__V_CMP_LE_F16();
19999
20000         int
20001         getNumOperands() override
20002         {
20003             return numDstRegOperands() + numSrcRegOperands();
20004         } // getNumOperands
20005
20006         int numDstRegOperands() override { return 1; }
20007         int numSrcRegOperands() override { return 2; }
20008
20009         int
20010         getOperandSize(int opIdx) override
20011         {
20012             switch (opIdx) {
20013               case 0: //src_0
20014                 return 2;
20015               case 1: //src_1
20016                 return 2;
20017               case 2: //vcc
20018                 return 8;
20019               default:
20020                 fatal("op idx %i out of bounds\n", opIdx);
20021                 return -1;
20022             }
20023         } // getOperandSize
20024
20025         bool
20026         isSrcOperand(int opIdx) override
20027         {
20028             switch (opIdx) {
20029               case 0: //src_0
20030                 return true;
20031               case 1: //src_1
20032                 return true;
20033               case 2: //vcc
20034                 return false;
20035               default:
20036                 fatal("op idx %i out of bounds\n", opIdx);
20037                 return false;
20038             }
20039         } // isSrcOperand
20040
20041         bool
20042         isDstOperand(int opIdx) override
20043         {
20044             switch (opIdx) {
20045               case 0: //src_0
20046                 return false;
20047               case 1: //src_1
20048                 return false;
20049               case 2: //vcc
20050                 return true;
20051               default:
20052                 fatal("op idx %i out of bounds\n", opIdx);
20053                 return false;
20054             }
20055         } // isDstOperand
20056
20057         void execute(GPUDynInstPtr) override;
20058     }; // Inst_VOPC__V_CMP_LE_F16
20059
20060     class Inst_VOPC__V_CMP_GT_F16 : public Inst_VOPC
20061     {
20062       public:
20063         Inst_VOPC__V_CMP_GT_F16(InFmt_VOPC*);
20064         ~Inst_VOPC__V_CMP_GT_F16();
20065
20066         int
20067         getNumOperands() override
20068         {
20069             return numDstRegOperands() + numSrcRegOperands();
20070         } // getNumOperands
20071
20072         int numDstRegOperands() override { return 1; }
20073         int numSrcRegOperands() override { return 2; }
20074
20075         int
20076         getOperandSize(int opIdx) override
20077         {
20078             switch (opIdx) {
20079               case 0: //src_0
20080                 return 2;
20081               case 1: //src_1
20082                 return 2;
20083               case 2: //vcc
20084                 return 8;
20085               default:
20086                 fatal("op idx %i out of bounds\n", opIdx);
20087                 return -1;
20088             }
20089         } // getOperandSize
20090
20091         bool
20092         isSrcOperand(int opIdx) override
20093         {
20094             switch (opIdx) {
20095               case 0: //src_0
20096                 return true;
20097               case 1: //src_1
20098                 return true;
20099               case 2: //vcc
20100                 return false;
20101               default:
20102                 fatal("op idx %i out of bounds\n", opIdx);
20103                 return false;
20104             }
20105         } // isSrcOperand
20106
20107         bool
20108         isDstOperand(int opIdx) override
20109         {
20110             switch (opIdx) {
20111               case 0: //src_0
20112                 return false;
20113               case 1: //src_1
20114                 return false;
20115               case 2: //vcc
20116                 return true;
20117               default:
20118                 fatal("op idx %i out of bounds\n", opIdx);
20119                 return false;
20120             }
20121         } // isDstOperand
20122
20123         void execute(GPUDynInstPtr) override;
20124     }; // Inst_VOPC__V_CMP_GT_F16
20125
20126     class Inst_VOPC__V_CMP_LG_F16 : public Inst_VOPC
20127     {
20128       public:
20129         Inst_VOPC__V_CMP_LG_F16(InFmt_VOPC*);
20130         ~Inst_VOPC__V_CMP_LG_F16();
20131
20132         int
20133         getNumOperands() override
20134         {
20135             return numDstRegOperands() + numSrcRegOperands();
20136         } // getNumOperands
20137
20138         int numDstRegOperands() override { return 1; }
20139         int numSrcRegOperands() override { return 2; }
20140
20141         int
20142         getOperandSize(int opIdx) override
20143         {
20144             switch (opIdx) {
20145               case 0: //src_0
20146                 return 2;
20147               case 1: //src_1
20148                 return 2;
20149               case 2: //vcc
20150                 return 8;
20151               default:
20152                 fatal("op idx %i out of bounds\n", opIdx);
20153                 return -1;
20154             }
20155         } // getOperandSize
20156
20157         bool
20158         isSrcOperand(int opIdx) override
20159         {
20160             switch (opIdx) {
20161               case 0: //src_0
20162                 return true;
20163               case 1: //src_1
20164                 return true;
20165               case 2: //vcc
20166                 return false;
20167               default:
20168                 fatal("op idx %i out of bounds\n", opIdx);
20169                 return false;
20170             }
20171         } // isSrcOperand
20172
20173         bool
20174         isDstOperand(int opIdx) override
20175         {
20176             switch (opIdx) {
20177               case 0: //src_0
20178                 return false;
20179               case 1: //src_1
20180                 return false;
20181               case 2: //vcc
20182                 return true;
20183               default:
20184                 fatal("op idx %i out of bounds\n", opIdx);
20185                 return false;
20186             }
20187         } // isDstOperand
20188
20189         void execute(GPUDynInstPtr) override;
20190     }; // Inst_VOPC__V_CMP_LG_F16
20191
20192     class Inst_VOPC__V_CMP_GE_F16 : public Inst_VOPC
20193     {
20194       public:
20195         Inst_VOPC__V_CMP_GE_F16(InFmt_VOPC*);
20196         ~Inst_VOPC__V_CMP_GE_F16();
20197
20198         int
20199         getNumOperands() override
20200         {
20201             return numDstRegOperands() + numSrcRegOperands();
20202         } // getNumOperands
20203
20204         int numDstRegOperands() override { return 1; }
20205         int numSrcRegOperands() override { return 2; }
20206
20207         int
20208         getOperandSize(int opIdx) override
20209         {
20210             switch (opIdx) {
20211               case 0: //src_0
20212                 return 2;
20213               case 1: //src_1
20214                 return 2;
20215               case 2: //vcc
20216                 return 8;
20217               default:
20218                 fatal("op idx %i out of bounds\n", opIdx);
20219                 return -1;
20220             }
20221         } // getOperandSize
20222
20223         bool
20224         isSrcOperand(int opIdx) override
20225         {
20226             switch (opIdx) {
20227               case 0: //src_0
20228                 return true;
20229               case 1: //src_1
20230                 return true;
20231               case 2: //vcc
20232                 return false;
20233               default:
20234                 fatal("op idx %i out of bounds\n", opIdx);
20235                 return false;
20236             }
20237         } // isSrcOperand
20238
20239         bool
20240         isDstOperand(int opIdx) override
20241         {
20242             switch (opIdx) {
20243               case 0: //src_0
20244                 return false;
20245               case 1: //src_1
20246                 return false;
20247               case 2: //vcc
20248                 return true;
20249               default:
20250                 fatal("op idx %i out of bounds\n", opIdx);
20251                 return false;
20252             }
20253         } // isDstOperand
20254
20255         void execute(GPUDynInstPtr) override;
20256     }; // Inst_VOPC__V_CMP_GE_F16
20257
20258     class Inst_VOPC__V_CMP_O_F16 : public Inst_VOPC
20259     {
20260       public:
20261         Inst_VOPC__V_CMP_O_F16(InFmt_VOPC*);
20262         ~Inst_VOPC__V_CMP_O_F16();
20263
20264         int
20265         getNumOperands() override
20266         {
20267             return numDstRegOperands() + numSrcRegOperands();
20268         } // getNumOperands
20269
20270         int numDstRegOperands() override { return 1; }
20271         int numSrcRegOperands() override { return 2; }
20272
20273         int
20274         getOperandSize(int opIdx) override
20275         {
20276             switch (opIdx) {
20277               case 0: //src_0
20278                 return 2;
20279               case 1: //src_1
20280                 return 2;
20281               case 2: //vcc
20282                 return 8;
20283               default:
20284                 fatal("op idx %i out of bounds\n", opIdx);
20285                 return -1;
20286             }
20287         } // getOperandSize
20288
20289         bool
20290         isSrcOperand(int opIdx) override
20291         {
20292             switch (opIdx) {
20293               case 0: //src_0
20294                 return true;
20295               case 1: //src_1
20296                 return true;
20297               case 2: //vcc
20298                 return false;
20299               default:
20300                 fatal("op idx %i out of bounds\n", opIdx);
20301                 return false;
20302             }
20303         } // isSrcOperand
20304
20305         bool
20306         isDstOperand(int opIdx) override
20307         {
20308             switch (opIdx) {
20309               case 0: //src_0
20310                 return false;
20311               case 1: //src_1
20312                 return false;
20313               case 2: //vcc
20314                 return true;
20315               default:
20316                 fatal("op idx %i out of bounds\n", opIdx);
20317                 return false;
20318             }
20319         } // isDstOperand
20320
20321         void execute(GPUDynInstPtr) override;
20322     }; // Inst_VOPC__V_CMP_O_F16
20323
20324     class Inst_VOPC__V_CMP_U_F16 : public Inst_VOPC
20325     {
20326       public:
20327         Inst_VOPC__V_CMP_U_F16(InFmt_VOPC*);
20328         ~Inst_VOPC__V_CMP_U_F16();
20329
20330         int
20331         getNumOperands() override
20332         {
20333             return numDstRegOperands() + numSrcRegOperands();
20334         } // getNumOperands
20335
20336         int numDstRegOperands() override { return 1; }
20337         int numSrcRegOperands() override { return 2; }
20338
20339         int
20340         getOperandSize(int opIdx) override
20341         {
20342             switch (opIdx) {
20343               case 0: //src_0
20344                 return 2;
20345               case 1: //src_1
20346                 return 2;
20347               case 2: //vcc
20348                 return 8;
20349               default:
20350                 fatal("op idx %i out of bounds\n", opIdx);
20351                 return -1;
20352             }
20353         } // getOperandSize
20354
20355         bool
20356         isSrcOperand(int opIdx) override
20357         {
20358             switch (opIdx) {
20359               case 0: //src_0
20360                 return true;
20361               case 1: //src_1
20362                 return true;
20363               case 2: //vcc
20364                 return false;
20365               default:
20366                 fatal("op idx %i out of bounds\n", opIdx);
20367                 return false;
20368             }
20369         } // isSrcOperand
20370
20371         bool
20372         isDstOperand(int opIdx) override
20373         {
20374             switch (opIdx) {
20375               case 0: //src_0
20376                 return false;
20377               case 1: //src_1
20378                 return false;
20379               case 2: //vcc
20380                 return true;
20381               default:
20382                 fatal("op idx %i out of bounds\n", opIdx);
20383                 return false;
20384             }
20385         } // isDstOperand
20386
20387         void execute(GPUDynInstPtr) override;
20388     }; // Inst_VOPC__V_CMP_U_F16
20389
20390     class Inst_VOPC__V_CMP_NGE_F16 : public Inst_VOPC
20391     {
20392       public:
20393         Inst_VOPC__V_CMP_NGE_F16(InFmt_VOPC*);
20394         ~Inst_VOPC__V_CMP_NGE_F16();
20395
20396         int
20397         getNumOperands() override
20398         {
20399             return numDstRegOperands() + numSrcRegOperands();
20400         } // getNumOperands
20401
20402         int numDstRegOperands() override { return 1; }
20403         int numSrcRegOperands() override { return 2; }
20404
20405         int
20406         getOperandSize(int opIdx) override
20407         {
20408             switch (opIdx) {
20409               case 0: //src_0
20410                 return 2;
20411               case 1: //src_1
20412                 return 2;
20413               case 2: //vcc
20414                 return 8;
20415               default:
20416                 fatal("op idx %i out of bounds\n", opIdx);
20417                 return -1;
20418             }
20419         } // getOperandSize
20420
20421         bool
20422         isSrcOperand(int opIdx) override
20423         {
20424             switch (opIdx) {
20425               case 0: //src_0
20426                 return true;
20427               case 1: //src_1
20428                 return true;
20429               case 2: //vcc
20430                 return false;
20431               default:
20432                 fatal("op idx %i out of bounds\n", opIdx);
20433                 return false;
20434             }
20435         } // isSrcOperand
20436
20437         bool
20438         isDstOperand(int opIdx) override
20439         {
20440             switch (opIdx) {
20441               case 0: //src_0
20442                 return false;
20443               case 1: //src_1
20444                 return false;
20445               case 2: //vcc
20446                 return true;
20447               default:
20448                 fatal("op idx %i out of bounds\n", opIdx);
20449                 return false;
20450             }
20451         } // isDstOperand
20452
20453         void execute(GPUDynInstPtr) override;
20454     }; // Inst_VOPC__V_CMP_NGE_F16
20455
20456     class Inst_VOPC__V_CMP_NLG_F16 : public Inst_VOPC
20457     {
20458       public:
20459         Inst_VOPC__V_CMP_NLG_F16(InFmt_VOPC*);
20460         ~Inst_VOPC__V_CMP_NLG_F16();
20461
20462         int
20463         getNumOperands() override
20464         {
20465             return numDstRegOperands() + numSrcRegOperands();
20466         } // getNumOperands
20467
20468         int numDstRegOperands() override { return 1; }
20469         int numSrcRegOperands() override { return 2; }
20470
20471         int
20472         getOperandSize(int opIdx) override
20473         {
20474             switch (opIdx) {
20475               case 0: //src_0
20476                 return 2;
20477               case 1: //src_1
20478                 return 2;
20479               case 2: //vcc
20480                 return 8;
20481               default:
20482                 fatal("op idx %i out of bounds\n", opIdx);
20483                 return -1;
20484             }
20485         } // getOperandSize
20486
20487         bool
20488         isSrcOperand(int opIdx) override
20489         {
20490             switch (opIdx) {
20491               case 0: //src_0
20492                 return true;
20493               case 1: //src_1
20494                 return true;
20495               case 2: //vcc
20496                 return false;
20497               default:
20498                 fatal("op idx %i out of bounds\n", opIdx);
20499                 return false;
20500             }
20501         } // isSrcOperand
20502
20503         bool
20504         isDstOperand(int opIdx) override
20505         {
20506             switch (opIdx) {
20507               case 0: //src_0
20508                 return false;
20509               case 1: //src_1
20510                 return false;
20511               case 2: //vcc
20512                 return true;
20513               default:
20514                 fatal("op idx %i out of bounds\n", opIdx);
20515                 return false;
20516             }
20517         } // isDstOperand
20518
20519         void execute(GPUDynInstPtr) override;
20520     }; // Inst_VOPC__V_CMP_NLG_F16
20521
20522     class Inst_VOPC__V_CMP_NGT_F16 : public Inst_VOPC
20523     {
20524       public:
20525         Inst_VOPC__V_CMP_NGT_F16(InFmt_VOPC*);
20526         ~Inst_VOPC__V_CMP_NGT_F16();
20527
20528         int
20529         getNumOperands() override
20530         {
20531             return numDstRegOperands() + numSrcRegOperands();
20532         } // getNumOperands
20533
20534         int numDstRegOperands() override { return 1; }
20535         int numSrcRegOperands() override { return 2; }
20536
20537         int
20538         getOperandSize(int opIdx) override
20539         {
20540             switch (opIdx) {
20541               case 0: //src_0
20542                 return 2;
20543               case 1: //src_1
20544                 return 2;
20545               case 2: //vcc
20546                 return 8;
20547               default:
20548                 fatal("op idx %i out of bounds\n", opIdx);
20549                 return -1;
20550             }
20551         } // getOperandSize
20552
20553         bool
20554         isSrcOperand(int opIdx) override
20555         {
20556             switch (opIdx) {
20557               case 0: //src_0
20558                 return true;
20559               case 1: //src_1
20560                 return true;
20561               case 2: //vcc
20562                 return false;
20563               default:
20564                 fatal("op idx %i out of bounds\n", opIdx);
20565                 return false;
20566             }
20567         } // isSrcOperand
20568
20569         bool
20570         isDstOperand(int opIdx) override
20571         {
20572             switch (opIdx) {
20573               case 0: //src_0
20574                 return false;
20575               case 1: //src_1
20576                 return false;
20577               case 2: //vcc
20578                 return true;
20579               default:
20580                 fatal("op idx %i out of bounds\n", opIdx);
20581                 return false;
20582             }
20583         } // isDstOperand
20584
20585         void execute(GPUDynInstPtr) override;
20586     }; // Inst_VOPC__V_CMP_NGT_F16
20587
20588     class Inst_VOPC__V_CMP_NLE_F16 : public Inst_VOPC
20589     {
20590       public:
20591         Inst_VOPC__V_CMP_NLE_F16(InFmt_VOPC*);
20592         ~Inst_VOPC__V_CMP_NLE_F16();
20593
20594         int
20595         getNumOperands() override
20596         {
20597             return numDstRegOperands() + numSrcRegOperands();
20598         } // getNumOperands
20599
20600         int numDstRegOperands() override { return 1; }
20601         int numSrcRegOperands() override { return 2; }
20602
20603         int
20604         getOperandSize(int opIdx) override
20605         {
20606             switch (opIdx) {
20607               case 0: //src_0
20608                 return 2;
20609               case 1: //src_1
20610                 return 2;
20611               case 2: //vcc
20612                 return 8;
20613               default:
20614                 fatal("op idx %i out of bounds\n", opIdx);
20615                 return -1;
20616             }
20617         } // getOperandSize
20618
20619         bool
20620         isSrcOperand(int opIdx) override
20621         {
20622             switch (opIdx) {
20623               case 0: //src_0
20624                 return true;
20625               case 1: //src_1
20626                 return true;
20627               case 2: //vcc
20628                 return false;
20629               default:
20630                 fatal("op idx %i out of bounds\n", opIdx);
20631                 return false;
20632             }
20633         } // isSrcOperand
20634
20635         bool
20636         isDstOperand(int opIdx) override
20637         {
20638             switch (opIdx) {
20639               case 0: //src_0
20640                 return false;
20641               case 1: //src_1
20642                 return false;
20643               case 2: //vcc
20644                 return true;
20645               default:
20646                 fatal("op idx %i out of bounds\n", opIdx);
20647                 return false;
20648             }
20649         } // isDstOperand
20650
20651         void execute(GPUDynInstPtr) override;
20652     }; // Inst_VOPC__V_CMP_NLE_F16
20653
20654     class Inst_VOPC__V_CMP_NEQ_F16 : public Inst_VOPC
20655     {
20656       public:
20657         Inst_VOPC__V_CMP_NEQ_F16(InFmt_VOPC*);
20658         ~Inst_VOPC__V_CMP_NEQ_F16();
20659
20660         int
20661         getNumOperands() override
20662         {
20663             return numDstRegOperands() + numSrcRegOperands();
20664         } // getNumOperands
20665
20666         int numDstRegOperands() override { return 1; }
20667         int numSrcRegOperands() override { return 2; }
20668
20669         int
20670         getOperandSize(int opIdx) override
20671         {
20672             switch (opIdx) {
20673               case 0: //src_0
20674                 return 2;
20675               case 1: //src_1
20676                 return 2;
20677               case 2: //vcc
20678                 return 8;
20679               default:
20680                 fatal("op idx %i out of bounds\n", opIdx);
20681                 return -1;
20682             }
20683         } // getOperandSize
20684
20685         bool
20686         isSrcOperand(int opIdx) override
20687         {
20688             switch (opIdx) {
20689               case 0: //src_0
20690                 return true;
20691               case 1: //src_1
20692                 return true;
20693               case 2: //vcc
20694                 return false;
20695               default:
20696                 fatal("op idx %i out of bounds\n", opIdx);
20697                 return false;
20698             }
20699         } // isSrcOperand
20700
20701         bool
20702         isDstOperand(int opIdx) override
20703         {
20704             switch (opIdx) {
20705               case 0: //src_0
20706                 return false;
20707               case 1: //src_1
20708                 return false;
20709               case 2: //vcc
20710                 return true;
20711               default:
20712                 fatal("op idx %i out of bounds\n", opIdx);
20713                 return false;
20714             }
20715         } // isDstOperand
20716
20717         void execute(GPUDynInstPtr) override;
20718     }; // Inst_VOPC__V_CMP_NEQ_F16
20719
20720     class Inst_VOPC__V_CMP_NLT_F16 : public Inst_VOPC
20721     {
20722       public:
20723         Inst_VOPC__V_CMP_NLT_F16(InFmt_VOPC*);
20724         ~Inst_VOPC__V_CMP_NLT_F16();
20725
20726         int
20727         getNumOperands() override
20728         {
20729             return numDstRegOperands() + numSrcRegOperands();
20730         } // getNumOperands
20731
20732         int numDstRegOperands() override { return 1; }
20733         int numSrcRegOperands() override { return 2; }
20734
20735         int
20736         getOperandSize(int opIdx) override
20737         {
20738             switch (opIdx) {
20739               case 0: //src_0
20740                 return 2;
20741               case 1: //src_1
20742                 return 2;
20743               case 2: //vcc
20744                 return 8;
20745               default:
20746                 fatal("op idx %i out of bounds\n", opIdx);
20747                 return -1;
20748             }
20749         } // getOperandSize
20750
20751         bool
20752         isSrcOperand(int opIdx) override
20753         {
20754             switch (opIdx) {
20755               case 0: //src_0
20756                 return true;
20757               case 1: //src_1
20758                 return true;
20759               case 2: //vcc
20760                 return false;
20761               default:
20762                 fatal("op idx %i out of bounds\n", opIdx);
20763                 return false;
20764             }
20765         } // isSrcOperand
20766
20767         bool
20768         isDstOperand(int opIdx) override
20769         {
20770             switch (opIdx) {
20771               case 0: //src_0
20772                 return false;
20773               case 1: //src_1
20774                 return false;
20775               case 2: //vcc
20776                 return true;
20777               default:
20778                 fatal("op idx %i out of bounds\n", opIdx);
20779                 return false;
20780             }
20781         } // isDstOperand
20782
20783         void execute(GPUDynInstPtr) override;
20784     }; // Inst_VOPC__V_CMP_NLT_F16
20785
20786     class Inst_VOPC__V_CMP_TRU_F16 : public Inst_VOPC
20787     {
20788       public:
20789         Inst_VOPC__V_CMP_TRU_F16(InFmt_VOPC*);
20790         ~Inst_VOPC__V_CMP_TRU_F16();
20791
20792         int
20793         getNumOperands() override
20794         {
20795             return numDstRegOperands() + numSrcRegOperands();
20796         } // getNumOperands
20797
20798         int numDstRegOperands() override { return 1; }
20799         int numSrcRegOperands() override { return 2; }
20800
20801         int
20802         getOperandSize(int opIdx) override
20803         {
20804             switch (opIdx) {
20805               case 0: //src_0
20806                 return 2;
20807               case 1: //src_1
20808                 return 2;
20809               case 2: //vcc
20810                 return 8;
20811               default:
20812                 fatal("op idx %i out of bounds\n", opIdx);
20813                 return -1;
20814             }
20815         } // getOperandSize
20816
20817         bool
20818         isSrcOperand(int opIdx) override
20819         {
20820             switch (opIdx) {
20821               case 0: //src_0
20822                 return true;
20823               case 1: //src_1
20824                 return true;
20825               default:
20826                 fatal("op idx %i out of bounds\n", opIdx);
20827                 return false;
20828             }
20829         } // isSrcOperand
20830
20831         bool
20832         isDstOperand(int opIdx) override
20833         {
20834             switch (opIdx) {
20835               case 0: //src_0
20836                 return false;
20837               case 1: //src_1
20838                 return false;
20839               default:
20840                 fatal("op idx %i out of bounds\n", opIdx);
20841                 return false;
20842             }
20843         } // isDstOperand
20844
20845         void execute(GPUDynInstPtr) override;
20846     }; // Inst_VOPC__V_CMP_TRU_F16
20847
20848     class Inst_VOPC__V_CMPX_F_F16 : public Inst_VOPC
20849     {
20850       public:
20851         Inst_VOPC__V_CMPX_F_F16(InFmt_VOPC*);
20852         ~Inst_VOPC__V_CMPX_F_F16();
20853
20854         int
20855         getNumOperands() override
20856         {
20857             return numDstRegOperands() + numSrcRegOperands();
20858         } // getNumOperands
20859
20860         int numDstRegOperands() override { return 1; }
20861         int numSrcRegOperands() override { return 2; }
20862
20863         int
20864         getOperandSize(int opIdx) override
20865         {
20866             switch (opIdx) {
20867               case 0: //src_0
20868                 return 2;
20869               case 1: //src_1
20870                 return 2;
20871               case 2: //vcc
20872                 return 8;
20873               default:
20874                 fatal("op idx %i out of bounds\n", opIdx);
20875                 return -1;
20876             }
20877         } // getOperandSize
20878
20879         bool
20880         isSrcOperand(int opIdx) override
20881         {
20882             switch (opIdx) {
20883               case 0: //src_0
20884                 return true;
20885               case 1: //src_1
20886                 return true;
20887               default:
20888                 fatal("op idx %i out of bounds\n", opIdx);
20889                 return false;
20890             }
20891         } // isSrcOperand
20892
20893         bool
20894         isDstOperand(int opIdx) override
20895         {
20896             switch (opIdx) {
20897               case 0: //src_0
20898                 return false;
20899               case 1: //src_1
20900                 return false;
20901               default:
20902                 fatal("op idx %i out of bounds\n", opIdx);
20903                 return false;
20904             }
20905         } // isDstOperand
20906
20907         void execute(GPUDynInstPtr) override;
20908     }; // Inst_VOPC__V_CMPX_F_F16
20909
20910     class Inst_VOPC__V_CMPX_LT_F16 : public Inst_VOPC
20911     {
20912       public:
20913         Inst_VOPC__V_CMPX_LT_F16(InFmt_VOPC*);
20914         ~Inst_VOPC__V_CMPX_LT_F16();
20915
20916         int
20917         getNumOperands() override
20918         {
20919             return numDstRegOperands() + numSrcRegOperands();
20920         } // getNumOperands
20921
20922         int numDstRegOperands() override { return 1; }
20923         int numSrcRegOperands() override { return 2; }
20924
20925         int
20926         getOperandSize(int opIdx) override
20927         {
20928             switch (opIdx) {
20929               case 0: //src_0
20930                 return 2;
20931               case 1: //src_1
20932                 return 2;
20933               case 2: //vcc
20934                 return 8;
20935               default:
20936                 fatal("op idx %i out of bounds\n", opIdx);
20937                 return -1;
20938             }
20939         } // getOperandSize
20940
20941         bool
20942         isSrcOperand(int opIdx) override
20943         {
20944             switch (opIdx) {
20945               case 0: //src_0
20946                 return true;
20947               case 1: //src_1
20948                 return true;
20949               default:
20950                 fatal("op idx %i out of bounds\n", opIdx);
20951                 return false;
20952             }
20953         } // isSrcOperand
20954
20955         bool
20956         isDstOperand(int opIdx) override
20957         {
20958             switch (opIdx) {
20959               case 0: //src_0
20960                 return false;
20961               case 1: //src_1
20962                 return false;
20963               default:
20964                 fatal("op idx %i out of bounds\n", opIdx);
20965                 return false;
20966             }
20967         } // isDstOperand
20968
20969         void execute(GPUDynInstPtr) override;
20970     }; // Inst_VOPC__V_CMPX_LT_F16
20971
20972     class Inst_VOPC__V_CMPX_EQ_F16 : public Inst_VOPC
20973     {
20974       public:
20975         Inst_VOPC__V_CMPX_EQ_F16(InFmt_VOPC*);
20976         ~Inst_VOPC__V_CMPX_EQ_F16();
20977
20978         int
20979         getNumOperands() override
20980         {
20981             return numDstRegOperands() + numSrcRegOperands();
20982         } // getNumOperands
20983
20984         int numDstRegOperands() override { return 1; }
20985         int numSrcRegOperands() override { return 2; }
20986
20987         int
20988         getOperandSize(int opIdx) override
20989         {
20990             switch (opIdx) {
20991               case 0: //src_0
20992                 return 2;
20993               case 1: //src_1
20994                 return 2;
20995               case 2: //vcc
20996                 return 8;
20997               default:
20998                 fatal("op idx %i out of bounds\n", opIdx);
20999                 return -1;
21000             }
21001         } // getOperandSize
21002
21003         bool
21004         isSrcOperand(int opIdx) override
21005         {
21006             switch (opIdx) {
21007               case 0: //src_0
21008                 return true;
21009               case 1: //src_1
21010                 return true;
21011               default:
21012                 fatal("op idx %i out of bounds\n", opIdx);
21013                 return false;
21014             }
21015         } // isSrcOperand
21016
21017         bool
21018         isDstOperand(int opIdx) override
21019         {
21020             switch (opIdx) {
21021               case 0: //src_0
21022                 return false;
21023               case 1: //src_1
21024                 return false;
21025               default:
21026                 fatal("op idx %i out of bounds\n", opIdx);
21027                 return false;
21028             }
21029         } // isDstOperand
21030
21031         void execute(GPUDynInstPtr) override;
21032     }; // Inst_VOPC__V_CMPX_EQ_F16
21033
21034     class Inst_VOPC__V_CMPX_LE_F16 : public Inst_VOPC
21035     {
21036       public:
21037         Inst_VOPC__V_CMPX_LE_F16(InFmt_VOPC*);
21038         ~Inst_VOPC__V_CMPX_LE_F16();
21039
21040         int
21041         getNumOperands() override
21042         {
21043             return numDstRegOperands() + numSrcRegOperands();
21044         } // getNumOperands
21045
21046         int numDstRegOperands() override { return 1; }
21047         int numSrcRegOperands() override { return 2; }
21048
21049         int
21050         getOperandSize(int opIdx) override
21051         {
21052             switch (opIdx) {
21053               case 0: //src_0
21054                 return 2;
21055               case 1: //src_1
21056                 return 2;
21057               case 2: //vcc
21058                 return 8;
21059               default:
21060                 fatal("op idx %i out of bounds\n", opIdx);
21061                 return -1;
21062             }
21063         } // getOperandSize
21064
21065         bool
21066         isSrcOperand(int opIdx) override
21067         {
21068             switch (opIdx) {
21069               case 0: //src_0
21070                 return true;
21071               case 1: //src_1
21072                 return true;
21073               default:
21074                 fatal("op idx %i out of bounds\n", opIdx);
21075                 return false;
21076             }
21077         } // isSrcOperand
21078
21079         bool
21080         isDstOperand(int opIdx) override
21081         {
21082             switch (opIdx) {
21083               case 0: //src_0
21084                 return false;
21085               case 1: //src_1
21086                 return false;
21087               default:
21088                 fatal("op idx %i out of bounds\n", opIdx);
21089                 return false;
21090             }
21091         } // isDstOperand
21092
21093         void execute(GPUDynInstPtr) override;
21094     }; // Inst_VOPC__V_CMPX_LE_F16
21095
21096     class Inst_VOPC__V_CMPX_GT_F16 : public Inst_VOPC
21097     {
21098       public:
21099         Inst_VOPC__V_CMPX_GT_F16(InFmt_VOPC*);
21100         ~Inst_VOPC__V_CMPX_GT_F16();
21101
21102         int
21103         getNumOperands() override
21104         {
21105             return numDstRegOperands() + numSrcRegOperands();
21106         } // getNumOperands
21107
21108         int numDstRegOperands() override { return 1; }
21109         int numSrcRegOperands() override { return 2; }
21110
21111         int
21112         getOperandSize(int opIdx) override
21113         {
21114             switch (opIdx) {
21115               case 0: //src_0
21116                 return 2;
21117               case 1: //src_1
21118                 return 2;
21119               case 2: //vcc
21120                 return 8;
21121               default:
21122                 fatal("op idx %i out of bounds\n", opIdx);
21123                 return -1;
21124             }
21125         } // getOperandSize
21126
21127         bool
21128         isSrcOperand(int opIdx) override
21129         {
21130             switch (opIdx) {
21131               case 0: //src_0
21132                 return true;
21133               case 1: //src_1
21134                 return true;
21135               default:
21136                 fatal("op idx %i out of bounds\n", opIdx);
21137                 return false;
21138             }
21139         } // isSrcOperand
21140
21141         bool
21142         isDstOperand(int opIdx) override
21143         {
21144             switch (opIdx) {
21145               case 0: //src_0
21146                 return false;
21147               case 1: //src_1
21148                 return false;
21149               default:
21150                 fatal("op idx %i out of bounds\n", opIdx);
21151                 return false;
21152             }
21153         } // isDstOperand
21154
21155         void execute(GPUDynInstPtr) override;
21156     }; // Inst_VOPC__V_CMPX_GT_F16
21157
21158     class Inst_VOPC__V_CMPX_LG_F16 : public Inst_VOPC
21159     {
21160       public:
21161         Inst_VOPC__V_CMPX_LG_F16(InFmt_VOPC*);
21162         ~Inst_VOPC__V_CMPX_LG_F16();
21163
21164         int
21165         getNumOperands() override
21166         {
21167             return numDstRegOperands() + numSrcRegOperands();
21168         } // getNumOperands
21169
21170         int numDstRegOperands() override { return 1; }
21171         int numSrcRegOperands() override { return 2; }
21172
21173         int
21174         getOperandSize(int opIdx) override
21175         {
21176             switch (opIdx) {
21177               case 0: //src_0
21178                 return 2;
21179               case 1: //src_1
21180                 return 2;
21181               case 2: //vcc
21182                 return 8;
21183               default:
21184                 fatal("op idx %i out of bounds\n", opIdx);
21185                 return -1;
21186             }
21187         } // getOperandSize
21188
21189         bool
21190         isSrcOperand(int opIdx) override
21191         {
21192             switch (opIdx) {
21193               case 0: //src_0
21194                 return true;
21195               case 1: //src_1
21196                 return true;
21197               default:
21198                 fatal("op idx %i out of bounds\n", opIdx);
21199                 return false;
21200             }
21201         } // isSrcOperand
21202
21203         bool
21204         isDstOperand(int opIdx) override
21205         {
21206             switch (opIdx) {
21207               case 0: //src_0
21208                 return false;
21209               case 1: //src_1
21210                 return false;
21211               default:
21212                 fatal("op idx %i out of bounds\n", opIdx);
21213                 return false;
21214             }
21215         } // isDstOperand
21216
21217         void execute(GPUDynInstPtr) override;
21218     }; // Inst_VOPC__V_CMPX_LG_F16
21219
21220     class Inst_VOPC__V_CMPX_GE_F16 : public Inst_VOPC
21221     {
21222       public:
21223         Inst_VOPC__V_CMPX_GE_F16(InFmt_VOPC*);
21224         ~Inst_VOPC__V_CMPX_GE_F16();
21225
21226         int
21227         getNumOperands() override
21228         {
21229             return numDstRegOperands() + numSrcRegOperands();
21230         } // getNumOperands
21231
21232         int numDstRegOperands() override { return 1; }
21233         int numSrcRegOperands() override { return 2; }
21234
21235         int
21236         getOperandSize(int opIdx) override
21237         {
21238             switch (opIdx) {
21239               case 0: //src_0
21240                 return 2;
21241               case 1: //src_1
21242                 return 2;
21243               case 2: //vcc
21244                 return 8;
21245               default:
21246                 fatal("op idx %i out of bounds\n", opIdx);
21247                 return -1;
21248             }
21249         } // getOperandSize
21250
21251         bool
21252         isSrcOperand(int opIdx) override
21253         {
21254             switch (opIdx) {
21255               case 0: //src_0
21256                 return true;
21257               case 1: //src_1
21258                 return true;
21259               default:
21260                 fatal("op idx %i out of bounds\n", opIdx);
21261                 return false;
21262             }
21263         } // isSrcOperand
21264
21265         bool
21266         isDstOperand(int opIdx) override
21267         {
21268             switch (opIdx) {
21269               case 0: //src_0
21270                 return false;
21271               case 1: //src_1
21272                 return false;
21273               default:
21274                 fatal("op idx %i out of bounds\n", opIdx);
21275                 return false;
21276             }
21277         } // isDstOperand
21278
21279         void execute(GPUDynInstPtr) override;
21280     }; // Inst_VOPC__V_CMPX_GE_F16
21281
21282     class Inst_VOPC__V_CMPX_O_F16 : public Inst_VOPC
21283     {
21284       public:
21285         Inst_VOPC__V_CMPX_O_F16(InFmt_VOPC*);
21286         ~Inst_VOPC__V_CMPX_O_F16();
21287
21288         int
21289         getNumOperands() override
21290         {
21291             return numDstRegOperands() + numSrcRegOperands();
21292         } // getNumOperands
21293
21294         int numDstRegOperands() override { return 1; }
21295         int numSrcRegOperands() override { return 2; }
21296
21297         int
21298         getOperandSize(int opIdx) override
21299         {
21300             switch (opIdx) {
21301               case 0: //src_0
21302                 return 2;
21303               case 1: //src_1
21304                 return 2;
21305               case 2: //vcc
21306                 return 8;
21307               default:
21308                 fatal("op idx %i out of bounds\n", opIdx);
21309                 return -1;
21310             }
21311         } // getOperandSize
21312
21313         bool
21314         isSrcOperand(int opIdx) override
21315         {
21316             switch (opIdx) {
21317               case 0: //src_0
21318                 return true;
21319               case 1: //src_1
21320                 return true;
21321               default:
21322                 fatal("op idx %i out of bounds\n", opIdx);
21323                 return false;
21324             }
21325         } // isSrcOperand
21326
21327         bool
21328         isDstOperand(int opIdx) override
21329         {
21330             switch (opIdx) {
21331               case 0: //src_0
21332                 return false;
21333               case 1: //src_1
21334                 return false;
21335               default:
21336                 fatal("op idx %i out of bounds\n", opIdx);
21337                 return false;
21338             }
21339         } // isDstOperand
21340
21341         void execute(GPUDynInstPtr) override;
21342     }; // Inst_VOPC__V_CMPX_O_F16
21343
21344     class Inst_VOPC__V_CMPX_U_F16 : public Inst_VOPC
21345     {
21346       public:
21347         Inst_VOPC__V_CMPX_U_F16(InFmt_VOPC*);
21348         ~Inst_VOPC__V_CMPX_U_F16();
21349
21350         int
21351         getNumOperands() override
21352         {
21353             return numDstRegOperands() + numSrcRegOperands();
21354         } // getNumOperands
21355
21356         int numDstRegOperands() override { return 1; }
21357         int numSrcRegOperands() override { return 2; }
21358
21359         int
21360         getOperandSize(int opIdx) override
21361         {
21362             switch (opIdx) {
21363               case 0: //src_0
21364                 return 2;
21365               case 1: //src_1
21366                 return 2;
21367               case 2: //vcc
21368                 return 8;
21369               default:
21370                 fatal("op idx %i out of bounds\n", opIdx);
21371                 return -1;
21372             }
21373         } // getOperandSize
21374
21375         bool
21376         isSrcOperand(int opIdx) override
21377         {
21378             switch (opIdx) {
21379               case 0: //src_0
21380                 return true;
21381               case 1: //src_1
21382                 return true;
21383               default:
21384                 fatal("op idx %i out of bounds\n", opIdx);
21385                 return false;
21386             }
21387         } // isSrcOperand
21388
21389         bool
21390         isDstOperand(int opIdx) override
21391         {
21392             switch (opIdx) {
21393               case 0: //src_0
21394                 return false;
21395               case 1: //src_1
21396                 return false;
21397               default:
21398                 fatal("op idx %i out of bounds\n", opIdx);
21399                 return false;
21400             }
21401         } // isDstOperand
21402
21403         void execute(GPUDynInstPtr) override;
21404     }; // Inst_VOPC__V_CMPX_U_F16
21405
21406     class Inst_VOPC__V_CMPX_NGE_F16 : public Inst_VOPC
21407     {
21408       public:
21409         Inst_VOPC__V_CMPX_NGE_F16(InFmt_VOPC*);
21410         ~Inst_VOPC__V_CMPX_NGE_F16();
21411
21412         int
21413         getNumOperands() override
21414         {
21415             return numDstRegOperands() + numSrcRegOperands();
21416         } // getNumOperands
21417
21418         int numDstRegOperands() override { return 1; }
21419         int numSrcRegOperands() override { return 2; }
21420
21421         int
21422         getOperandSize(int opIdx) override
21423         {
21424             switch (opIdx) {
21425               case 0: //src_0
21426                 return 2;
21427               case 1: //src_1
21428                 return 2;
21429               case 2: //vcc
21430                 return 8;
21431               default:
21432                 fatal("op idx %i out of bounds\n", opIdx);
21433                 return -1;
21434             }
21435         } // getOperandSize
21436
21437         bool
21438         isSrcOperand(int opIdx) override
21439         {
21440             switch (opIdx) {
21441               case 0: //src_0
21442                 return true;
21443               case 1: //src_1
21444                 return true;
21445               default:
21446                 fatal("op idx %i out of bounds\n", opIdx);
21447                 return false;
21448             }
21449         } // isSrcOperand
21450
21451         bool
21452         isDstOperand(int opIdx) override
21453         {
21454             switch (opIdx) {
21455               case 0: //src_0
21456                 return false;
21457               case 1: //src_1
21458                 return false;
21459               default:
21460                 fatal("op idx %i out of bounds\n", opIdx);
21461                 return false;
21462             }
21463         } // isDstOperand
21464
21465         void execute(GPUDynInstPtr) override;
21466     }; // Inst_VOPC__V_CMPX_NGE_F16
21467
21468     class Inst_VOPC__V_CMPX_NLG_F16 : public Inst_VOPC
21469     {
21470       public:
21471         Inst_VOPC__V_CMPX_NLG_F16(InFmt_VOPC*);
21472         ~Inst_VOPC__V_CMPX_NLG_F16();
21473
21474         int
21475         getNumOperands() override
21476         {
21477             return numDstRegOperands() + numSrcRegOperands();
21478         } // getNumOperands
21479
21480         int numDstRegOperands() override { return 1; }
21481         int numSrcRegOperands() override { return 2; }
21482
21483         int
21484         getOperandSize(int opIdx) override
21485         {
21486             switch (opIdx) {
21487               case 0: //src_0
21488                 return 2;
21489               case 1: //src_1
21490                 return 2;
21491               case 2: //vcc
21492                 return 8;
21493               default:
21494                 fatal("op idx %i out of bounds\n", opIdx);
21495                 return -1;
21496             }
21497         } // getOperandSize
21498
21499         bool
21500         isSrcOperand(int opIdx) override
21501         {
21502             switch (opIdx) {
21503               case 0: //src_0
21504                 return true;
21505               case 1: //src_1
21506                 return true;
21507               default:
21508                 fatal("op idx %i out of bounds\n", opIdx);
21509                 return false;
21510             }
21511         } // isSrcOperand
21512
21513         bool
21514         isDstOperand(int opIdx) override
21515         {
21516             switch (opIdx) {
21517               case 0: //src_0
21518                 return false;
21519               case 1: //src_1
21520                 return false;
21521               default:
21522                 fatal("op idx %i out of bounds\n", opIdx);
21523                 return false;
21524             }
21525         } // isDstOperand
21526
21527         void execute(GPUDynInstPtr) override;
21528     }; // Inst_VOPC__V_CMPX_NLG_F16
21529
21530     class Inst_VOPC__V_CMPX_NGT_F16 : public Inst_VOPC
21531     {
21532       public:
21533         Inst_VOPC__V_CMPX_NGT_F16(InFmt_VOPC*);
21534         ~Inst_VOPC__V_CMPX_NGT_F16();
21535
21536         int
21537         getNumOperands() override
21538         {
21539             return numDstRegOperands() + numSrcRegOperands();
21540         } // getNumOperands
21541
21542         int numDstRegOperands() override { return 1; }
21543         int numSrcRegOperands() override { return 2; }
21544
21545         int
21546         getOperandSize(int opIdx) override
21547         {
21548             switch (opIdx) {
21549               case 0: //src_0
21550                 return 2;
21551               case 1: //src_1
21552                 return 2;
21553               case 2: //vcc
21554                 return 8;
21555               default:
21556                 fatal("op idx %i out of bounds\n", opIdx);
21557                 return -1;
21558             }
21559         } // getOperandSize
21560
21561         bool
21562         isSrcOperand(int opIdx) override
21563         {
21564             switch (opIdx) {
21565               case 0: //src_0
21566                 return true;
21567               case 1: //src_1
21568                 return true;
21569               default:
21570                 fatal("op idx %i out of bounds\n", opIdx);
21571                 return false;
21572             }
21573         } // isSrcOperand
21574
21575         bool
21576         isDstOperand(int opIdx) override
21577         {
21578             switch (opIdx) {
21579               case 0: //src_0
21580                 return false;
21581               case 1: //src_1
21582                 return false;
21583               default:
21584                 fatal("op idx %i out of bounds\n", opIdx);
21585                 return false;
21586             }
21587         } // isDstOperand
21588
21589         void execute(GPUDynInstPtr) override;
21590     }; // Inst_VOPC__V_CMPX_NGT_F16
21591
21592     class Inst_VOPC__V_CMPX_NLE_F16 : public Inst_VOPC
21593     {
21594       public:
21595         Inst_VOPC__V_CMPX_NLE_F16(InFmt_VOPC*);
21596         ~Inst_VOPC__V_CMPX_NLE_F16();
21597
21598         int
21599         getNumOperands() override
21600         {
21601             return numDstRegOperands() + numSrcRegOperands();
21602         } // getNumOperands
21603
21604         int numDstRegOperands() override { return 1; }
21605         int numSrcRegOperands() override { return 2; }
21606
21607         int
21608         getOperandSize(int opIdx) override
21609         {
21610             switch (opIdx) {
21611               case 0: //src_0
21612                 return 2;
21613               case 1: //src_1
21614                 return 2;
21615               case 2: //vcc
21616                 return 8;
21617               default:
21618                 fatal("op idx %i out of bounds\n", opIdx);
21619                 return -1;
21620             }
21621         } // getOperandSize
21622
21623         bool
21624         isSrcOperand(int opIdx) override
21625         {
21626             switch (opIdx) {
21627               case 0: //src_0
21628                 return true;
21629               case 1: //src_1
21630                 return true;
21631               default:
21632                 fatal("op idx %i out of bounds\n", opIdx);
21633                 return false;
21634             }
21635         } // isSrcOperand
21636
21637         bool
21638         isDstOperand(int opIdx) override
21639         {
21640             switch (opIdx) {
21641               case 0: //src_0
21642                 return false;
21643               case 1: //src_1
21644                 return false;
21645               default:
21646                 fatal("op idx %i out of bounds\n", opIdx);
21647                 return false;
21648             }
21649         } // isDstOperand
21650
21651         void execute(GPUDynInstPtr) override;
21652     }; // Inst_VOPC__V_CMPX_NLE_F16
21653
21654     class Inst_VOPC__V_CMPX_NEQ_F16 : public Inst_VOPC
21655     {
21656       public:
21657         Inst_VOPC__V_CMPX_NEQ_F16(InFmt_VOPC*);
21658         ~Inst_VOPC__V_CMPX_NEQ_F16();
21659
21660         int
21661         getNumOperands() override
21662         {
21663             return numDstRegOperands() + numSrcRegOperands();
21664         } // getNumOperands
21665
21666         int numDstRegOperands() override { return 1; }
21667         int numSrcRegOperands() override { return 2; }
21668
21669         int
21670         getOperandSize(int opIdx) override
21671         {
21672             switch (opIdx) {
21673               case 0: //src_0
21674                 return 2;
21675               case 1: //src_1
21676                 return 2;
21677               case 2: //vcc
21678                 return 8;
21679               default:
21680                 fatal("op idx %i out of bounds\n", opIdx);
21681                 return -1;
21682             }
21683         } // getOperandSize
21684
21685         bool
21686         isSrcOperand(int opIdx) override
21687         {
21688             switch (opIdx) {
21689               case 0: //src_0
21690                 return true;
21691               case 1: //src_1
21692                 return true;
21693               default:
21694                 fatal("op idx %i out of bounds\n", opIdx);
21695                 return false;
21696             }
21697         } // isSrcOperand
21698
21699         bool
21700         isDstOperand(int opIdx) override
21701         {
21702             switch (opIdx) {
21703               case 0: //src_0
21704                 return false;
21705               case 1: //src_1
21706                 return false;
21707               default:
21708                 fatal("op idx %i out of bounds\n", opIdx);
21709                 return false;
21710             }
21711         } // isDstOperand
21712
21713         void execute(GPUDynInstPtr) override;
21714     }; // Inst_VOPC__V_CMPX_NEQ_F16
21715
21716     class Inst_VOPC__V_CMPX_NLT_F16 : public Inst_VOPC
21717     {
21718       public:
21719         Inst_VOPC__V_CMPX_NLT_F16(InFmt_VOPC*);
21720         ~Inst_VOPC__V_CMPX_NLT_F16();
21721
21722         int
21723         getNumOperands() override
21724         {
21725             return numDstRegOperands() + numSrcRegOperands();
21726         } // getNumOperands
21727
21728         int numDstRegOperands() override { return 1; }
21729         int numSrcRegOperands() override { return 2; }
21730
21731         int
21732         getOperandSize(int opIdx) override
21733         {
21734             switch (opIdx) {
21735               case 0: //src_0
21736                 return 2;
21737               case 1: //src_1
21738                 return 2;
21739               case 2: //vcc
21740                 return 8;
21741               default:
21742                 fatal("op idx %i out of bounds\n", opIdx);
21743                 return -1;
21744             }
21745         } // getOperandSize
21746
21747         bool
21748         isSrcOperand(int opIdx) override
21749         {
21750             switch (opIdx) {
21751               case 0: //src_0
21752                 return true;
21753               case 1: //src_1
21754                 return true;
21755               default:
21756                 fatal("op idx %i out of bounds\n", opIdx);
21757                 return false;
21758             }
21759         } // isSrcOperand
21760
21761         bool
21762         isDstOperand(int opIdx) override
21763         {
21764             switch (opIdx) {
21765               case 0: //src_0
21766                 return false;
21767               case 1: //src_1
21768                 return false;
21769               default:
21770                 fatal("op idx %i out of bounds\n", opIdx);
21771                 return false;
21772             }
21773         } // isDstOperand
21774
21775         void execute(GPUDynInstPtr) override;
21776     }; // Inst_VOPC__V_CMPX_NLT_F16
21777
21778     class Inst_VOPC__V_CMPX_TRU_F16 : public Inst_VOPC
21779     {
21780       public:
21781         Inst_VOPC__V_CMPX_TRU_F16(InFmt_VOPC*);
21782         ~Inst_VOPC__V_CMPX_TRU_F16();
21783
21784         int
21785         getNumOperands() override
21786         {
21787             return numDstRegOperands() + numSrcRegOperands();
21788         } // getNumOperands
21789
21790         int numDstRegOperands() override { return 1; }
21791         int numSrcRegOperands() override { return 2; }
21792
21793         int
21794         getOperandSize(int opIdx) override
21795         {
21796             switch (opIdx) {
21797               case 0: //src_0
21798                 return 2;
21799               case 1: //src_1
21800                 return 2;
21801               case 2: //vcc
21802                 return 8;
21803               default:
21804                 fatal("op idx %i out of bounds\n", opIdx);
21805                 return -1;
21806             }
21807         } // getOperandSize
21808
21809         bool
21810         isSrcOperand(int opIdx) override
21811         {
21812             switch (opIdx) {
21813               case 0: //src_0
21814                 return true;
21815               case 1: //src_1
21816                 return true;
21817               default:
21818                 fatal("op idx %i out of bounds\n", opIdx);
21819                 return false;
21820             }
21821         } // isSrcOperand
21822
21823         bool
21824         isDstOperand(int opIdx) override
21825         {
21826             switch (opIdx) {
21827               case 0: //src_0
21828                 return false;
21829               case 1: //src_1
21830                 return false;
21831               default:
21832                 fatal("op idx %i out of bounds\n", opIdx);
21833                 return false;
21834             }
21835         } // isDstOperand
21836
21837         void execute(GPUDynInstPtr) override;
21838     }; // Inst_VOPC__V_CMPX_TRU_F16
21839
21840     class Inst_VOPC__V_CMP_F_F32 : public Inst_VOPC
21841     {
21842       public:
21843         Inst_VOPC__V_CMP_F_F32(InFmt_VOPC*);
21844         ~Inst_VOPC__V_CMP_F_F32();
21845
21846         int
21847         getNumOperands() override
21848         {
21849             return numDstRegOperands() + numSrcRegOperands();
21850         } // getNumOperands
21851
21852         int numDstRegOperands() override { return 1; }
21853         int numSrcRegOperands() override { return 2; }
21854
21855         int
21856         getOperandSize(int opIdx) override
21857         {
21858             switch (opIdx) {
21859               case 0: //src_0
21860                 return 4;
21861               case 1: //src_1
21862                 return 4;
21863               case 2: //vcc
21864                 return 8;
21865               default:
21866                 fatal("op idx %i out of bounds\n", opIdx);
21867                 return -1;
21868             }
21869         } // getOperandSize
21870
21871         bool
21872         isSrcOperand(int opIdx) override
21873         {
21874             switch (opIdx) {
21875               case 0: //src_0
21876                 return true;
21877               case 1: //src_1
21878                 return true;
21879               case 2: //vcc
21880                 return false;
21881               default:
21882                 fatal("op idx %i out of bounds\n", opIdx);
21883                 return false;
21884             }
21885         } // isSrcOperand
21886
21887         bool
21888         isDstOperand(int opIdx) override
21889         {
21890             switch (opIdx) {
21891               case 0: //src_0
21892                 return false;
21893               case 1: //src_1
21894                 return false;
21895               case 2: //vcc
21896                 return true;
21897               default:
21898                 fatal("op idx %i out of bounds\n", opIdx);
21899                 return false;
21900             }
21901         } // isDstOperand
21902
21903         void execute(GPUDynInstPtr) override;
21904     }; // Inst_VOPC__V_CMP_F_F32
21905
21906     class Inst_VOPC__V_CMP_LT_F32 : public Inst_VOPC
21907     {
21908       public:
21909         Inst_VOPC__V_CMP_LT_F32(InFmt_VOPC*);
21910         ~Inst_VOPC__V_CMP_LT_F32();
21911
21912         int
21913         getNumOperands() override
21914         {
21915             return numDstRegOperands() + numSrcRegOperands();
21916         } // getNumOperands
21917
21918         int numDstRegOperands() override { return 1; }
21919         int numSrcRegOperands() override { return 2; }
21920
21921         int
21922         getOperandSize(int opIdx) override
21923         {
21924             switch (opIdx) {
21925               case 0: //src_0
21926                 return 4;
21927               case 1: //src_1
21928                 return 4;
21929               case 2: //vcc
21930                 return 8;
21931               default:
21932                 fatal("op idx %i out of bounds\n", opIdx);
21933                 return -1;
21934             }
21935         } // getOperandSize
21936
21937         bool
21938         isSrcOperand(int opIdx) override
21939         {
21940             switch (opIdx) {
21941               case 0: //src_0
21942                 return true;
21943               case 1: //src_1
21944                 return true;
21945               case 2: //vcc
21946                 return false;
21947               default:
21948                 fatal("op idx %i out of bounds\n", opIdx);
21949                 return false;
21950             }
21951         } // isSrcOperand
21952
21953         bool
21954         isDstOperand(int opIdx) override
21955         {
21956             switch (opIdx) {
21957               case 0: //src_0
21958                 return false;
21959               case 1: //src_1
21960                 return false;
21961               case 2: //vcc
21962                 return true;
21963               default:
21964                 fatal("op idx %i out of bounds\n", opIdx);
21965                 return false;
21966             }
21967         } // isDstOperand
21968
21969         void execute(GPUDynInstPtr) override;
21970     }; // Inst_VOPC__V_CMP_LT_F32
21971
21972     class Inst_VOPC__V_CMP_EQ_F32 : public Inst_VOPC
21973     {
21974       public:
21975         Inst_VOPC__V_CMP_EQ_F32(InFmt_VOPC*);
21976         ~Inst_VOPC__V_CMP_EQ_F32();
21977
21978         int
21979         getNumOperands() override
21980         {
21981             return numDstRegOperands() + numSrcRegOperands();
21982         } // getNumOperands
21983
21984         int numDstRegOperands() override { return 1; }
21985         int numSrcRegOperands() override { return 2; }
21986
21987         int
21988         getOperandSize(int opIdx) override
21989         {
21990             switch (opIdx) {
21991               case 0: //src_0
21992                 return 4;
21993               case 1: //src_1
21994                 return 4;
21995               case 2: //vcc
21996                 return 8;
21997               default:
21998                 fatal("op idx %i out of bounds\n", opIdx);
21999                 return -1;
22000             }
22001         } // getOperandSize
22002
22003         bool
22004         isSrcOperand(int opIdx) override
22005         {
22006             switch (opIdx) {
22007               case 0: //src_0
22008                 return true;
22009               case 1: //src_1
22010                 return true;
22011               case 2: //vcc
22012                 return false;
22013               default:
22014                 fatal("op idx %i out of bounds\n", opIdx);
22015                 return false;
22016             }
22017         } // isSrcOperand
22018
22019         bool
22020         isDstOperand(int opIdx) override
22021         {
22022             switch (opIdx) {
22023               case 0: //src_0
22024                 return false;
22025               case 1: //src_1
22026                 return false;
22027               case 2: //vcc
22028                 return true;
22029               default:
22030                 fatal("op idx %i out of bounds\n", opIdx);
22031                 return false;
22032             }
22033         } // isDstOperand
22034
22035         void execute(GPUDynInstPtr) override;
22036     }; // Inst_VOPC__V_CMP_EQ_F32
22037
22038     class Inst_VOPC__V_CMP_LE_F32 : public Inst_VOPC
22039     {
22040       public:
22041         Inst_VOPC__V_CMP_LE_F32(InFmt_VOPC*);
22042         ~Inst_VOPC__V_CMP_LE_F32();
22043
22044         int
22045         getNumOperands() override
22046         {
22047             return numDstRegOperands() + numSrcRegOperands();
22048         } // getNumOperands
22049
22050         int numDstRegOperands() override { return 1; }
22051         int numSrcRegOperands() override { return 2; }
22052
22053         int
22054         getOperandSize(int opIdx) override
22055         {
22056             switch (opIdx) {
22057               case 0: //src_0
22058                 return 4;
22059               case 1: //src_1
22060                 return 4;
22061               case 2: //vcc
22062                 return 8;
22063               default:
22064                 fatal("op idx %i out of bounds\n", opIdx);
22065                 return -1;
22066             }
22067         } // getOperandSize
22068
22069         bool
22070         isSrcOperand(int opIdx) override
22071         {
22072             switch (opIdx) {
22073               case 0: //src_0
22074                 return true;
22075               case 1: //src_1
22076                 return true;
22077               case 2: //vcc
22078                 return false;
22079               default:
22080                 fatal("op idx %i out of bounds\n", opIdx);
22081                 return false;
22082             }
22083         } // isSrcOperand
22084
22085         bool
22086         isDstOperand(int opIdx) override
22087         {
22088             switch (opIdx) {
22089               case 0: //src_0
22090                 return false;
22091               case 1: //src_1
22092                 return false;
22093               case 2: //vcc
22094                 return true;
22095               default:
22096                 fatal("op idx %i out of bounds\n", opIdx);
22097                 return false;
22098             }
22099         } // isDstOperand
22100
22101         void execute(GPUDynInstPtr) override;
22102     }; // Inst_VOPC__V_CMP_LE_F32
22103
22104     class Inst_VOPC__V_CMP_GT_F32 : public Inst_VOPC
22105     {
22106       public:
22107         Inst_VOPC__V_CMP_GT_F32(InFmt_VOPC*);
22108         ~Inst_VOPC__V_CMP_GT_F32();
22109
22110         int
22111         getNumOperands() override
22112         {
22113             return numDstRegOperands() + numSrcRegOperands();
22114         } // getNumOperands
22115
22116         int numDstRegOperands() override { return 1; }
22117         int numSrcRegOperands() override { return 2; }
22118
22119         int
22120         getOperandSize(int opIdx) override
22121         {
22122             switch (opIdx) {
22123               case 0: //src_0
22124                 return 4;
22125               case 1: //src_1
22126                 return 4;
22127               case 2: //vcc
22128                 return 8;
22129               default:
22130                 fatal("op idx %i out of bounds\n", opIdx);
22131                 return -1;
22132             }
22133         } // getOperandSize
22134
22135         bool
22136         isSrcOperand(int opIdx) override
22137         {
22138             switch (opIdx) {
22139               case 0: //src_0
22140                 return true;
22141               case 1: //src_1
22142                 return true;
22143               case 2: //vcc
22144                 return false;
22145               default:
22146                 fatal("op idx %i out of bounds\n", opIdx);
22147                 return false;
22148             }
22149         } // isSrcOperand
22150
22151         bool
22152         isDstOperand(int opIdx) override
22153         {
22154             switch (opIdx) {
22155               case 0: //src_0
22156                 return false;
22157               case 1: //src_1
22158                 return false;
22159               case 2: //vcc
22160                 return true;
22161               default:
22162                 fatal("op idx %i out of bounds\n", opIdx);
22163                 return false;
22164             }
22165         } // isDstOperand
22166
22167         void execute(GPUDynInstPtr) override;
22168     }; // Inst_VOPC__V_CMP_GT_F32
22169
22170     class Inst_VOPC__V_CMP_LG_F32 : public Inst_VOPC
22171     {
22172       public:
22173         Inst_VOPC__V_CMP_LG_F32(InFmt_VOPC*);
22174         ~Inst_VOPC__V_CMP_LG_F32();
22175
22176         int
22177         getNumOperands() override
22178         {
22179             return numDstRegOperands() + numSrcRegOperands();
22180         } // getNumOperands
22181
22182         int numDstRegOperands() override { return 1; }
22183         int numSrcRegOperands() override { return 2; }
22184
22185         int
22186         getOperandSize(int opIdx) override
22187         {
22188             switch (opIdx) {
22189               case 0: //src_0
22190                 return 4;
22191               case 1: //src_1
22192                 return 4;
22193               case 2: //vcc
22194                 return 8;
22195               default:
22196                 fatal("op idx %i out of bounds\n", opIdx);
22197                 return -1;
22198             }
22199         } // getOperandSize
22200
22201         bool
22202         isSrcOperand(int opIdx) override
22203         {
22204             switch (opIdx) {
22205               case 0: //src_0
22206                 return true;
22207               case 1: //src_1
22208                 return true;
22209               case 2: //vcc
22210                 return false;
22211               default:
22212                 fatal("op idx %i out of bounds\n", opIdx);
22213                 return false;
22214             }
22215         } // isSrcOperand
22216
22217         bool
22218         isDstOperand(int opIdx) override
22219         {
22220             switch (opIdx) {
22221               case 0: //src_0
22222                 return false;
22223               case 1: //src_1
22224                 return false;
22225               case 2: //vcc
22226                 return true;
22227               default:
22228                 fatal("op idx %i out of bounds\n", opIdx);
22229                 return false;
22230             }
22231         } // isDstOperand
22232
22233         void execute(GPUDynInstPtr) override;
22234     }; // Inst_VOPC__V_CMP_LG_F32
22235
22236     class Inst_VOPC__V_CMP_GE_F32 : public Inst_VOPC
22237     {
22238       public:
22239         Inst_VOPC__V_CMP_GE_F32(InFmt_VOPC*);
22240         ~Inst_VOPC__V_CMP_GE_F32();
22241
22242         int
22243         getNumOperands() override
22244         {
22245             return numDstRegOperands() + numSrcRegOperands();
22246         } // getNumOperands
22247
22248         int numDstRegOperands() override { return 1; }
22249         int numSrcRegOperands() override { return 2; }
22250
22251         int
22252         getOperandSize(int opIdx) override
22253         {
22254             switch (opIdx) {
22255               case 0: //src_0
22256                 return 4;
22257               case 1: //src_1
22258                 return 4;
22259               case 2: //vcc
22260                 return 8;
22261               default:
22262                 fatal("op idx %i out of bounds\n", opIdx);
22263                 return -1;
22264             }
22265         } // getOperandSize
22266
22267         bool
22268         isSrcOperand(int opIdx) override
22269         {
22270             switch (opIdx) {
22271               case 0: //src_0
22272                 return true;
22273               case 1: //src_1
22274                 return true;
22275               case 2: //vcc
22276                 return false;
22277               default:
22278                 fatal("op idx %i out of bounds\n", opIdx);
22279                 return false;
22280             }
22281         } // isSrcOperand
22282
22283         bool
22284         isDstOperand(int opIdx) override
22285         {
22286             switch (opIdx) {
22287               case 0: //src_0
22288                 return false;
22289               case 1: //src_1
22290                 return false;
22291               case 2: //vcc
22292                 return true;
22293               default:
22294                 fatal("op idx %i out of bounds\n", opIdx);
22295                 return false;
22296             }
22297         } // isDstOperand
22298
22299         void execute(GPUDynInstPtr) override;
22300     }; // Inst_VOPC__V_CMP_GE_F32
22301
22302     class Inst_VOPC__V_CMP_O_F32 : public Inst_VOPC
22303     {
22304       public:
22305         Inst_VOPC__V_CMP_O_F32(InFmt_VOPC*);
22306         ~Inst_VOPC__V_CMP_O_F32();
22307
22308         int
22309         getNumOperands() override
22310         {
22311             return numDstRegOperands() + numSrcRegOperands();
22312         } // getNumOperands
22313
22314         int numDstRegOperands() override { return 1; }
22315         int numSrcRegOperands() override { return 2; }
22316
22317         int
22318         getOperandSize(int opIdx) override
22319         {
22320             switch (opIdx) {
22321               case 0: //src_0
22322                 return 4;
22323               case 1: //src_1
22324                 return 4;
22325               case 2: //vcc
22326                 return 8;
22327               default:
22328                 fatal("op idx %i out of bounds\n", opIdx);
22329                 return -1;
22330             }
22331         } // getOperandSize
22332
22333         bool
22334         isSrcOperand(int opIdx) override
22335         {
22336             switch (opIdx) {
22337               case 0: //src_0
22338                 return true;
22339               case 1: //src_1
22340                 return true;
22341               case 2: //vcc
22342                 return false;
22343               default:
22344                 fatal("op idx %i out of bounds\n", opIdx);
22345                 return false;
22346             }
22347         } // isSrcOperand
22348
22349         bool
22350         isDstOperand(int opIdx) override
22351         {
22352             switch (opIdx) {
22353               case 0: //src_0
22354                 return false;
22355               case 1: //src_1
22356                 return false;
22357               case 2: //vcc
22358                 return true;
22359               default:
22360                 fatal("op idx %i out of bounds\n", opIdx);
22361                 return false;
22362             }
22363         } // isDstOperand
22364
22365         void execute(GPUDynInstPtr) override;
22366     }; // Inst_VOPC__V_CMP_O_F32
22367
22368     class Inst_VOPC__V_CMP_U_F32 : public Inst_VOPC
22369     {
22370       public:
22371         Inst_VOPC__V_CMP_U_F32(InFmt_VOPC*);
22372         ~Inst_VOPC__V_CMP_U_F32();
22373
22374         int
22375         getNumOperands() override
22376         {
22377             return numDstRegOperands() + numSrcRegOperands();
22378         } // getNumOperands
22379
22380         int numDstRegOperands() override { return 1; }
22381         int numSrcRegOperands() override { return 2; }
22382
22383         int
22384         getOperandSize(int opIdx) override
22385         {
22386             switch (opIdx) {
22387               case 0: //src_0
22388                 return 4;
22389               case 1: //src_1
22390                 return 4;
22391               case 2: //vcc
22392                 return 8;
22393               default:
22394                 fatal("op idx %i out of bounds\n", opIdx);
22395                 return -1;
22396             }
22397         } // getOperandSize
22398
22399         bool
22400         isSrcOperand(int opIdx) override
22401         {
22402             switch (opIdx) {
22403               case 0: //src_0
22404                 return true;
22405               case 1: //src_1
22406                 return true;
22407               case 2: //vcc
22408                 return false;
22409               default:
22410                 fatal("op idx %i out of bounds\n", opIdx);
22411                 return false;
22412             }
22413         } // isSrcOperand
22414
22415         bool
22416         isDstOperand(int opIdx) override
22417         {
22418             switch (opIdx) {
22419               case 0: //src_0
22420                 return false;
22421               case 1: //src_1
22422                 return false;
22423               case 2: //vcc
22424                 return true;
22425               default:
22426                 fatal("op idx %i out of bounds\n", opIdx);
22427                 return false;
22428             }
22429         } // isDstOperand
22430
22431         void execute(GPUDynInstPtr) override;
22432     }; // Inst_VOPC__V_CMP_U_F32
22433
22434     class Inst_VOPC__V_CMP_NGE_F32 : public Inst_VOPC
22435     {
22436       public:
22437         Inst_VOPC__V_CMP_NGE_F32(InFmt_VOPC*);
22438         ~Inst_VOPC__V_CMP_NGE_F32();
22439
22440         int
22441         getNumOperands() override
22442         {
22443             return numDstRegOperands() + numSrcRegOperands();
22444         } // getNumOperands
22445
22446         int numDstRegOperands() override { return 1; }
22447         int numSrcRegOperands() override { return 2; }
22448
22449         int
22450         getOperandSize(int opIdx) override
22451         {
22452             switch (opIdx) {
22453               case 0: //src_0
22454                 return 4;
22455               case 1: //src_1
22456                 return 4;
22457               case 2: //vcc
22458                 return 8;
22459               default:
22460                 fatal("op idx %i out of bounds\n", opIdx);
22461                 return -1;
22462             }
22463         } // getOperandSize
22464
22465         bool
22466         isSrcOperand(int opIdx) override
22467         {
22468             switch (opIdx) {
22469               case 0: //src_0
22470                 return true;
22471               case 1: //src_1
22472                 return true;
22473               case 2: //vcc
22474                 return false;
22475               default:
22476                 fatal("op idx %i out of bounds\n", opIdx);
22477                 return false;
22478             }
22479         } // isSrcOperand
22480
22481         bool
22482         isDstOperand(int opIdx) override
22483         {
22484             switch (opIdx) {
22485               case 0: //src_0
22486                 return false;
22487               case 1: //src_1
22488                 return false;
22489               case 2: //vcc
22490                 return true;
22491               default:
22492                 fatal("op idx %i out of bounds\n", opIdx);
22493                 return false;
22494             }
22495         } // isDstOperand
22496
22497         void execute(GPUDynInstPtr) override;
22498     }; // Inst_VOPC__V_CMP_NGE_F32
22499
22500     class Inst_VOPC__V_CMP_NLG_F32 : public Inst_VOPC
22501     {
22502       public:
22503         Inst_VOPC__V_CMP_NLG_F32(InFmt_VOPC*);
22504         ~Inst_VOPC__V_CMP_NLG_F32();
22505
22506         int
22507         getNumOperands() override
22508         {
22509             return numDstRegOperands() + numSrcRegOperands();
22510         } // getNumOperands
22511
22512         int numDstRegOperands() override { return 1; }
22513         int numSrcRegOperands() override { return 2; }
22514
22515         int
22516         getOperandSize(int opIdx) override
22517         {
22518             switch (opIdx) {
22519               case 0: //src_0
22520                 return 4;
22521               case 1: //src_1
22522                 return 4;
22523               case 2: //vcc
22524                 return 8;
22525               default:
22526                 fatal("op idx %i out of bounds\n", opIdx);
22527                 return -1;
22528             }
22529         } // getOperandSize
22530
22531         bool
22532         isSrcOperand(int opIdx) override
22533         {
22534             switch (opIdx) {
22535               case 0: //src_0
22536                 return true;
22537               case 1: //src_1
22538                 return true;
22539               case 2: //vcc
22540                 return false;
22541               default:
22542                 fatal("op idx %i out of bounds\n", opIdx);
22543                 return false;
22544             }
22545         } // isSrcOperand
22546
22547         bool
22548         isDstOperand(int opIdx) override
22549         {
22550             switch (opIdx) {
22551               case 0: //src_0
22552                 return false;
22553               case 1: //src_1
22554                 return false;
22555               case 2: //vcc
22556                 return true;
22557               default:
22558                 fatal("op idx %i out of bounds\n", opIdx);
22559                 return false;
22560             }
22561         } // isDstOperand
22562
22563         void execute(GPUDynInstPtr) override;
22564     }; // Inst_VOPC__V_CMP_NLG_F32
22565
22566     class Inst_VOPC__V_CMP_NGT_F32 : public Inst_VOPC
22567     {
22568       public:
22569         Inst_VOPC__V_CMP_NGT_F32(InFmt_VOPC*);
22570         ~Inst_VOPC__V_CMP_NGT_F32();
22571
22572         int
22573         getNumOperands() override
22574         {
22575             return numDstRegOperands() + numSrcRegOperands();
22576         } // getNumOperands
22577
22578         int numDstRegOperands() override { return 1; }
22579         int numSrcRegOperands() override { return 2; }
22580
22581         int
22582         getOperandSize(int opIdx) override
22583         {
22584             switch (opIdx) {
22585               case 0: //src_0
22586                 return 4;
22587               case 1: //src_1
22588                 return 4;
22589               case 2: //vcc
22590                 return 8;
22591               default:
22592                 fatal("op idx %i out of bounds\n", opIdx);
22593                 return -1;
22594             }
22595         } // getOperandSize
22596
22597         bool
22598         isSrcOperand(int opIdx) override
22599         {
22600             switch (opIdx) {
22601               case 0: //src_0
22602                 return true;
22603               case 1: //src_1
22604                 return true;
22605               case 2: //vcc
22606                 return false;
22607               default:
22608                 fatal("op idx %i out of bounds\n", opIdx);
22609                 return false;
22610             }
22611         } // isSrcOperand
22612
22613         bool
22614         isDstOperand(int opIdx) override
22615         {
22616             switch (opIdx) {
22617               case 0: //src_0
22618                 return false;
22619               case 1: //src_1
22620                 return false;
22621               case 2: //vcc
22622                 return true;
22623               default:
22624                 fatal("op idx %i out of bounds\n", opIdx);
22625                 return false;
22626             }
22627         } // isDstOperand
22628
22629         void execute(GPUDynInstPtr) override;
22630     }; // Inst_VOPC__V_CMP_NGT_F32
22631
22632     class Inst_VOPC__V_CMP_NLE_F32 : public Inst_VOPC
22633     {
22634       public:
22635         Inst_VOPC__V_CMP_NLE_F32(InFmt_VOPC*);
22636         ~Inst_VOPC__V_CMP_NLE_F32();
22637
22638         int
22639         getNumOperands() override
22640         {
22641             return numDstRegOperands() + numSrcRegOperands();
22642         } // getNumOperands
22643
22644         int numDstRegOperands() override { return 1; }
22645         int numSrcRegOperands() override { return 2; }
22646
22647         int
22648         getOperandSize(int opIdx) override
22649         {
22650             switch (opIdx) {
22651               case 0: //src_0
22652                 return 4;
22653               case 1: //src_1
22654                 return 4;
22655               case 2: //vcc
22656                 return 8;
22657               default:
22658                 fatal("op idx %i out of bounds\n", opIdx);
22659                 return -1;
22660             }
22661         } // getOperandSize
22662
22663         bool
22664         isSrcOperand(int opIdx) override
22665         {
22666             switch (opIdx) {
22667               case 0: //src_0
22668                 return true;
22669               case 1: //src_1
22670                 return true;
22671               case 2: //vcc
22672                 return false;
22673               default:
22674                 fatal("op idx %i out of bounds\n", opIdx);
22675                 return false;
22676             }
22677         } // isSrcOperand
22678
22679         bool
22680         isDstOperand(int opIdx) override
22681         {
22682             switch (opIdx) {
22683               case 0: //src_0
22684                 return false;
22685               case 1: //src_1
22686                 return false;
22687               case 2: //vcc
22688                 return true;
22689               default:
22690                 fatal("op idx %i out of bounds\n", opIdx);
22691                 return false;
22692             }
22693         } // isDstOperand
22694
22695         void execute(GPUDynInstPtr) override;
22696     }; // Inst_VOPC__V_CMP_NLE_F32
22697
22698     class Inst_VOPC__V_CMP_NEQ_F32 : public Inst_VOPC
22699     {
22700       public:
22701         Inst_VOPC__V_CMP_NEQ_F32(InFmt_VOPC*);
22702         ~Inst_VOPC__V_CMP_NEQ_F32();
22703
22704         int
22705         getNumOperands() override
22706         {
22707             return numDstRegOperands() + numSrcRegOperands();
22708         } // getNumOperands
22709
22710         int numDstRegOperands() override { return 1; }
22711         int numSrcRegOperands() override { return 2; }
22712
22713         int
22714         getOperandSize(int opIdx) override
22715         {
22716             switch (opIdx) {
22717               case 0: //src_0
22718                 return 4;
22719               case 1: //src_1
22720                 return 4;
22721               case 2: //vcc
22722                 return 8;
22723               default:
22724                 fatal("op idx %i out of bounds\n", opIdx);
22725                 return -1;
22726             }
22727         } // getOperandSize
22728
22729         bool
22730         isSrcOperand(int opIdx) override
22731         {
22732             switch (opIdx) {
22733               case 0: //src_0
22734                 return true;
22735               case 1: //src_1
22736                 return true;
22737               case 2: //vcc
22738                 return false;
22739               default:
22740                 fatal("op idx %i out of bounds\n", opIdx);
22741                 return false;
22742             }
22743         } // isSrcOperand
22744
22745         bool
22746         isDstOperand(int opIdx) override
22747         {
22748             switch (opIdx) {
22749               case 0: //src_0
22750                 return false;
22751               case 1: //src_1
22752                 return false;
22753               case 2: //vcc
22754                 return true;
22755               default:
22756                 fatal("op idx %i out of bounds\n", opIdx);
22757                 return false;
22758             }
22759         } // isDstOperand
22760
22761         void execute(GPUDynInstPtr) override;
22762     }; // Inst_VOPC__V_CMP_NEQ_F32
22763
22764     class Inst_VOPC__V_CMP_NLT_F32 : public Inst_VOPC
22765     {
22766       public:
22767         Inst_VOPC__V_CMP_NLT_F32(InFmt_VOPC*);
22768         ~Inst_VOPC__V_CMP_NLT_F32();
22769
22770         int
22771         getNumOperands() override
22772         {
22773             return numDstRegOperands() + numSrcRegOperands();
22774         } // getNumOperands
22775
22776         int numDstRegOperands() override { return 1; }
22777         int numSrcRegOperands() override { return 2; }
22778
22779         int
22780         getOperandSize(int opIdx) override
22781         {
22782             switch (opIdx) {
22783               case 0: //src_0
22784                 return 4;
22785               case 1: //src_1
22786                 return 4;
22787               case 2: //vcc
22788                 return 8;
22789               default:
22790                 fatal("op idx %i out of bounds\n", opIdx);
22791                 return -1;
22792             }
22793         } // getOperandSize
22794
22795         bool
22796         isSrcOperand(int opIdx) override
22797         {
22798             switch (opIdx) {
22799               case 0: //src_0
22800                 return true;
22801               case 1: //src_1
22802                 return true;
22803               case 2: //vcc
22804                 return false;
22805               default:
22806                 fatal("op idx %i out of bounds\n", opIdx);
22807                 return false;
22808             }
22809         } // isSrcOperand
22810
22811         bool
22812         isDstOperand(int opIdx) override
22813         {
22814             switch (opIdx) {
22815               case 0: //src_0
22816                 return false;
22817               case 1: //src_1
22818                 return false;
22819               case 2: //vcc
22820                 return true;
22821               default:
22822                 fatal("op idx %i out of bounds\n", opIdx);
22823                 return false;
22824             }
22825         } // isDstOperand
22826
22827         void execute(GPUDynInstPtr) override;
22828     }; // Inst_VOPC__V_CMP_NLT_F32
22829
22830     class Inst_VOPC__V_CMP_TRU_F32 : public Inst_VOPC
22831     {
22832       public:
22833         Inst_VOPC__V_CMP_TRU_F32(InFmt_VOPC*);
22834         ~Inst_VOPC__V_CMP_TRU_F32();
22835
22836         int
22837         getNumOperands() override
22838         {
22839             return numDstRegOperands() + numSrcRegOperands();
22840         } // getNumOperands
22841
22842         int numDstRegOperands() override { return 1; }
22843         int numSrcRegOperands() override { return 2; }
22844
22845         int
22846         getOperandSize(int opIdx) override
22847         {
22848             switch (opIdx) {
22849               case 0: //src_0
22850                 return 4;
22851               case 1: //src_1
22852                 return 4;
22853               case 2: //vcc
22854                 return 8;
22855               default:
22856                 fatal("op idx %i out of bounds\n", opIdx);
22857                 return -1;
22858             }
22859         } // getOperandSize
22860
22861         bool
22862         isSrcOperand(int opIdx) override
22863         {
22864             switch (opIdx) {
22865               case 0: //src_0
22866                 return true;
22867               case 1: //src_1
22868                 return true;
22869               default:
22870                 fatal("op idx %i out of bounds\n", opIdx);
22871                 return false;
22872             }
22873         } // isSrcOperand
22874
22875         bool
22876         isDstOperand(int opIdx) override
22877         {
22878             switch (opIdx) {
22879               case 0: //src_0
22880                 return false;
22881               case 1: //src_1
22882                 return false;
22883               default:
22884                 fatal("op idx %i out of bounds\n", opIdx);
22885                 return false;
22886             }
22887         } // isDstOperand
22888
22889         void execute(GPUDynInstPtr) override;
22890     }; // Inst_VOPC__V_CMP_TRU_F32
22891
22892     class Inst_VOPC__V_CMPX_F_F32 : public Inst_VOPC
22893     {
22894       public:
22895         Inst_VOPC__V_CMPX_F_F32(InFmt_VOPC*);
22896         ~Inst_VOPC__V_CMPX_F_F32();
22897
22898         int
22899         getNumOperands() override
22900         {
22901             return numDstRegOperands() + numSrcRegOperands();
22902         } // getNumOperands
22903
22904         int numDstRegOperands() override { return 1; }
22905         int numSrcRegOperands() override { return 2; }
22906
22907         int
22908         getOperandSize(int opIdx) override
22909         {
22910             switch (opIdx) {
22911               case 0: //src_0
22912                 return 4;
22913               case 1: //src_1
22914                 return 4;
22915               case 2: //vcc
22916                 return 8;
22917               default:
22918                 fatal("op idx %i out of bounds\n", opIdx);
22919                 return -1;
22920             }
22921         } // getOperandSize
22922
22923         bool
22924         isSrcOperand(int opIdx) override
22925         {
22926             switch (opIdx) {
22927               case 0: //src_0
22928                 return true;
22929               case 1: //src_1
22930                 return true;
22931               default:
22932                 fatal("op idx %i out of bounds\n", opIdx);
22933                 return false;
22934             }
22935         } // isSrcOperand
22936
22937         bool
22938         isDstOperand(int opIdx) override
22939         {
22940             switch (opIdx) {
22941               case 0: //src_0
22942                 return false;
22943               case 1: //src_1
22944                 return false;
22945               default:
22946                 fatal("op idx %i out of bounds\n", opIdx);
22947                 return false;
22948             }
22949         } // isDstOperand
22950
22951         void execute(GPUDynInstPtr) override;
22952     }; // Inst_VOPC__V_CMPX_F_F32
22953
22954     class Inst_VOPC__V_CMPX_LT_F32 : public Inst_VOPC
22955     {
22956       public:
22957         Inst_VOPC__V_CMPX_LT_F32(InFmt_VOPC*);
22958         ~Inst_VOPC__V_CMPX_LT_F32();
22959
22960         int
22961         getNumOperands() override
22962         {
22963             return numDstRegOperands() + numSrcRegOperands();
22964         } // getNumOperands
22965
22966         int numDstRegOperands() override { return 1; }
22967         int numSrcRegOperands() override { return 2; }
22968
22969         int
22970         getOperandSize(int opIdx) override
22971         {
22972             switch (opIdx) {
22973               case 0: //src_0
22974                 return 4;
22975               case 1: //src_1
22976                 return 4;
22977               case 2: //vcc
22978                 return 8;
22979               default:
22980                 fatal("op idx %i out of bounds\n", opIdx);
22981                 return -1;
22982             }
22983         } // getOperandSize
22984
22985         bool
22986         isSrcOperand(int opIdx) override
22987         {
22988             switch (opIdx) {
22989               case 0: //src_0
22990                 return true;
22991               case 1: //src_1
22992                 return true;
22993               default:
22994                 fatal("op idx %i out of bounds\n", opIdx);
22995                 return false;
22996             }
22997         } // isSrcOperand
22998
22999         bool
23000         isDstOperand(int opIdx) override
23001         {
23002             switch (opIdx) {
23003               case 0: //src_0
23004                 return false;
23005               case 1: //src_1
23006                 return false;
23007               default:
23008                 fatal("op idx %i out of bounds\n", opIdx);
23009                 return false;
23010             }
23011         } // isDstOperand
23012
23013         void execute(GPUDynInstPtr) override;
23014     }; // Inst_VOPC__V_CMPX_LT_F32
23015
23016     class Inst_VOPC__V_CMPX_EQ_F32 : public Inst_VOPC
23017     {
23018       public:
23019         Inst_VOPC__V_CMPX_EQ_F32(InFmt_VOPC*);
23020         ~Inst_VOPC__V_CMPX_EQ_F32();
23021
23022         int
23023         getNumOperands() override
23024         {
23025             return numDstRegOperands() + numSrcRegOperands();
23026         } // getNumOperands
23027
23028         int numDstRegOperands() override { return 1; }
23029         int numSrcRegOperands() override { return 2; }
23030
23031         int
23032         getOperandSize(int opIdx) override
23033         {
23034             switch (opIdx) {
23035               case 0: //src_0
23036                 return 4;
23037               case 1: //src_1
23038                 return 4;
23039               case 2: //vcc
23040                 return 8;
23041               default:
23042                 fatal("op idx %i out of bounds\n", opIdx);
23043                 return -1;
23044             }
23045         } // getOperandSize
23046
23047         bool
23048         isSrcOperand(int opIdx) override
23049         {
23050             switch (opIdx) {
23051               case 0: //src_0
23052                 return true;
23053               case 1: //src_1
23054                 return true;
23055               default:
23056                 fatal("op idx %i out of bounds\n", opIdx);
23057                 return false;
23058             }
23059         } // isSrcOperand
23060
23061         bool
23062         isDstOperand(int opIdx) override
23063         {
23064             switch (opIdx) {
23065               case 0: //src_0
23066                 return false;
23067               case 1: //src_1
23068                 return false;
23069               default:
23070                 fatal("op idx %i out of bounds\n", opIdx);
23071                 return false;
23072             }
23073         } // isDstOperand
23074
23075         void execute(GPUDynInstPtr) override;
23076     }; // Inst_VOPC__V_CMPX_EQ_F32
23077
23078     class Inst_VOPC__V_CMPX_LE_F32 : public Inst_VOPC
23079     {
23080       public:
23081         Inst_VOPC__V_CMPX_LE_F32(InFmt_VOPC*);
23082         ~Inst_VOPC__V_CMPX_LE_F32();
23083
23084         int
23085         getNumOperands() override
23086         {
23087             return numDstRegOperands() + numSrcRegOperands();
23088         } // getNumOperands
23089
23090         int numDstRegOperands() override { return 1; }
23091         int numSrcRegOperands() override { return 2; }
23092
23093         int
23094         getOperandSize(int opIdx) override
23095         {
23096             switch (opIdx) {
23097               case 0: //src_0
23098                 return 4;
23099               case 1: //src_1
23100                 return 4;
23101               case 2: //vcc
23102                 return 8;
23103               default:
23104                 fatal("op idx %i out of bounds\n", opIdx);
23105                 return -1;
23106             }
23107         } // getOperandSize
23108
23109         bool
23110         isSrcOperand(int opIdx) override
23111         {
23112             switch (opIdx) {
23113               case 0: //src_0
23114                 return true;
23115               case 1: //src_1
23116                 return true;
23117               default:
23118                 fatal("op idx %i out of bounds\n", opIdx);
23119                 return false;
23120             }
23121         } // isSrcOperand
23122
23123         bool
23124         isDstOperand(int opIdx) override
23125         {
23126             switch (opIdx) {
23127               case 0: //src_0
23128                 return false;
23129               case 1: //src_1
23130                 return false;
23131               default:
23132                 fatal("op idx %i out of bounds\n", opIdx);
23133                 return false;
23134             }
23135         } // isDstOperand
23136
23137         void execute(GPUDynInstPtr) override;
23138     }; // Inst_VOPC__V_CMPX_LE_F32
23139
23140     class Inst_VOPC__V_CMPX_GT_F32 : public Inst_VOPC
23141     {
23142       public:
23143         Inst_VOPC__V_CMPX_GT_F32(InFmt_VOPC*);
23144         ~Inst_VOPC__V_CMPX_GT_F32();
23145
23146         int
23147         getNumOperands() override
23148         {
23149             return numDstRegOperands() + numSrcRegOperands();
23150         } // getNumOperands
23151
23152         int numDstRegOperands() override { return 1; }
23153         int numSrcRegOperands() override { return 2; }
23154
23155         int
23156         getOperandSize(int opIdx) override
23157         {
23158             switch (opIdx) {
23159               case 0: //src_0
23160                 return 4;
23161               case 1: //src_1
23162                 return 4;
23163               case 2: //vcc
23164                 return 8;
23165               default:
23166                 fatal("op idx %i out of bounds\n", opIdx);
23167                 return -1;
23168             }
23169         } // getOperandSize
23170
23171         bool
23172         isSrcOperand(int opIdx) override
23173         {
23174             switch (opIdx) {
23175               case 0: //src_0
23176                 return true;
23177               case 1: //src_1
23178                 return true;
23179               default:
23180                 fatal("op idx %i out of bounds\n", opIdx);
23181                 return false;
23182             }
23183         } // isSrcOperand
23184
23185         bool
23186         isDstOperand(int opIdx) override
23187         {
23188             switch (opIdx) {
23189               case 0: //src_0
23190                 return false;
23191               case 1: //src_1
23192                 return false;
23193               default:
23194                 fatal("op idx %i out of bounds\n", opIdx);
23195                 return false;
23196             }
23197         } // isDstOperand
23198
23199         void execute(GPUDynInstPtr) override;
23200     }; // Inst_VOPC__V_CMPX_GT_F32
23201
23202     class Inst_VOPC__V_CMPX_LG_F32 : public Inst_VOPC
23203     {
23204       public:
23205         Inst_VOPC__V_CMPX_LG_F32(InFmt_VOPC*);
23206         ~Inst_VOPC__V_CMPX_LG_F32();
23207
23208         int
23209         getNumOperands() override
23210         {
23211             return numDstRegOperands() + numSrcRegOperands();
23212         } // getNumOperands
23213
23214         int numDstRegOperands() override { return 1; }
23215         int numSrcRegOperands() override { return 2; }
23216
23217         int
23218         getOperandSize(int opIdx) override
23219         {
23220             switch (opIdx) {
23221               case 0: //src_0
23222                 return 4;
23223               case 1: //src_1
23224                 return 4;
23225               case 2: //vcc
23226                 return 8;
23227               default:
23228                 fatal("op idx %i out of bounds\n", opIdx);
23229                 return -1;
23230             }
23231         } // getOperandSize
23232
23233         bool
23234         isSrcOperand(int opIdx) override
23235         {
23236             switch (opIdx) {
23237               case 0: //src_0
23238                 return true;
23239               case 1: //src_1
23240                 return true;
23241               default:
23242                 fatal("op idx %i out of bounds\n", opIdx);
23243                 return false;
23244             }
23245         } // isSrcOperand
23246
23247         bool
23248         isDstOperand(int opIdx) override
23249         {
23250             switch (opIdx) {
23251               case 0: //src_0
23252                 return false;
23253               case 1: //src_1
23254                 return false;
23255               default:
23256                 fatal("op idx %i out of bounds\n", opIdx);
23257                 return false;
23258             }
23259         } // isDstOperand
23260
23261         void execute(GPUDynInstPtr) override;
23262     }; // Inst_VOPC__V_CMPX_LG_F32
23263
23264     class Inst_VOPC__V_CMPX_GE_F32 : public Inst_VOPC
23265     {
23266       public:
23267         Inst_VOPC__V_CMPX_GE_F32(InFmt_VOPC*);
23268         ~Inst_VOPC__V_CMPX_GE_F32();
23269
23270         int
23271         getNumOperands() override
23272         {
23273             return numDstRegOperands() + numSrcRegOperands();
23274         } // getNumOperands
23275
23276         int numDstRegOperands() override { return 1; }
23277         int numSrcRegOperands() override { return 2; }
23278
23279         int
23280         getOperandSize(int opIdx) override
23281         {
23282             switch (opIdx) {
23283               case 0: //src_0
23284                 return 4;
23285               case 1: //src_1
23286                 return 4;
23287               case 2: //vcc
23288                 return 8;
23289               default:
23290                 fatal("op idx %i out of bounds\n", opIdx);
23291                 return -1;
23292             }
23293         } // getOperandSize
23294
23295         bool
23296         isSrcOperand(int opIdx) override
23297         {
23298             switch (opIdx) {
23299               case 0: //src_0
23300                 return true;
23301               case 1: //src_1
23302                 return true;
23303               default:
23304                 fatal("op idx %i out of bounds\n", opIdx);
23305                 return false;
23306             }
23307         } // isSrcOperand
23308
23309         bool
23310         isDstOperand(int opIdx) override
23311         {
23312             switch (opIdx) {
23313               case 0: //src_0
23314                 return false;
23315               case 1: //src_1
23316                 return false;
23317               default:
23318                 fatal("op idx %i out of bounds\n", opIdx);
23319                 return false;
23320             }
23321         } // isDstOperand
23322
23323         void execute(GPUDynInstPtr) override;
23324     }; // Inst_VOPC__V_CMPX_GE_F32
23325
23326     class Inst_VOPC__V_CMPX_O_F32 : public Inst_VOPC
23327     {
23328       public:
23329         Inst_VOPC__V_CMPX_O_F32(InFmt_VOPC*);
23330         ~Inst_VOPC__V_CMPX_O_F32();
23331
23332         int
23333         getNumOperands() override
23334         {
23335             return numDstRegOperands() + numSrcRegOperands();
23336         } // getNumOperands
23337
23338         int numDstRegOperands() override { return 1; }
23339         int numSrcRegOperands() override { return 2; }
23340
23341         int
23342         getOperandSize(int opIdx) override
23343         {
23344             switch (opIdx) {
23345               case 0: //src_0
23346                 return 4;
23347               case 1: //src_1
23348                 return 4;
23349               case 2: //vcc
23350                 return 8;
23351               default:
23352                 fatal("op idx %i out of bounds\n", opIdx);
23353                 return -1;
23354             }
23355         } // getOperandSize
23356
23357         bool
23358         isSrcOperand(int opIdx) override
23359         {
23360             switch (opIdx) {
23361               case 0: //src_0
23362                 return true;
23363               case 1: //src_1
23364                 return true;
23365               default:
23366                 fatal("op idx %i out of bounds\n", opIdx);
23367                 return false;
23368             }
23369         } // isSrcOperand
23370
23371         bool
23372         isDstOperand(int opIdx) override
23373         {
23374             switch (opIdx) {
23375               case 0: //src_0
23376                 return false;
23377               case 1: //src_1
23378                 return false;
23379               default:
23380                 fatal("op idx %i out of bounds\n", opIdx);
23381                 return false;
23382             }
23383         } // isDstOperand
23384
23385         void execute(GPUDynInstPtr) override;
23386     }; // Inst_VOPC__V_CMPX_O_F32
23387
23388     class Inst_VOPC__V_CMPX_U_F32 : public Inst_VOPC
23389     {
23390       public:
23391         Inst_VOPC__V_CMPX_U_F32(InFmt_VOPC*);
23392         ~Inst_VOPC__V_CMPX_U_F32();
23393
23394         int
23395         getNumOperands() override
23396         {
23397             return numDstRegOperands() + numSrcRegOperands();
23398         } // getNumOperands
23399
23400         int numDstRegOperands() override { return 1; }
23401         int numSrcRegOperands() override { return 2; }
23402
23403         int
23404         getOperandSize(int opIdx) override
23405         {
23406             switch (opIdx) {
23407               case 0: //src_0
23408                 return 4;
23409               case 1: //src_1
23410                 return 4;
23411               case 2: //vcc
23412                 return 8;
23413               default:
23414                 fatal("op idx %i out of bounds\n", opIdx);
23415                 return -1;
23416             }
23417         } // getOperandSize
23418
23419         bool
23420         isSrcOperand(int opIdx) override
23421         {
23422             switch (opIdx) {
23423               case 0: //src_0
23424                 return true;
23425               case 1: //src_1
23426                 return true;
23427               default:
23428                 fatal("op idx %i out of bounds\n", opIdx);
23429                 return false;
23430             }
23431         } // isSrcOperand
23432
23433         bool
23434         isDstOperand(int opIdx) override
23435         {
23436             switch (opIdx) {
23437               case 0: //src_0
23438                 return false;
23439               case 1: //src_1
23440                 return false;
23441               default:
23442                 fatal("op idx %i out of bounds\n", opIdx);
23443                 return false;
23444             }
23445         } // isDstOperand
23446
23447         void execute(GPUDynInstPtr) override;
23448     }; // Inst_VOPC__V_CMPX_U_F32
23449
23450     class Inst_VOPC__V_CMPX_NGE_F32 : public Inst_VOPC
23451     {
23452       public:
23453         Inst_VOPC__V_CMPX_NGE_F32(InFmt_VOPC*);
23454         ~Inst_VOPC__V_CMPX_NGE_F32();
23455
23456         int
23457         getNumOperands() override
23458         {
23459             return numDstRegOperands() + numSrcRegOperands();
23460         } // getNumOperands
23461
23462         int numDstRegOperands() override { return 1; }
23463         int numSrcRegOperands() override { return 2; }
23464
23465         int
23466         getOperandSize(int opIdx) override
23467         {
23468             switch (opIdx) {
23469               case 0: //src_0
23470                 return 4;
23471               case 1: //src_1
23472                 return 4;
23473               case 2: //vcc
23474                 return 8;
23475               default:
23476                 fatal("op idx %i out of bounds\n", opIdx);
23477                 return -1;
23478             }
23479         } // getOperandSize
23480
23481         bool
23482         isSrcOperand(int opIdx) override
23483         {
23484             switch (opIdx) {
23485               case 0: //src_0
23486                 return true;
23487               case 1: //src_1
23488                 return true;
23489               default:
23490                 fatal("op idx %i out of bounds\n", opIdx);
23491                 return false;
23492             }
23493         } // isSrcOperand
23494
23495         bool
23496         isDstOperand(int opIdx) override
23497         {
23498             switch (opIdx) {
23499               case 0: //src_0
23500                 return false;
23501               case 1: //src_1
23502                 return false;
23503               default:
23504                 fatal("op idx %i out of bounds\n", opIdx);
23505                 return false;
23506             }
23507         } // isDstOperand
23508
23509         void execute(GPUDynInstPtr) override;
23510     }; // Inst_VOPC__V_CMPX_NGE_F32
23511
23512     class Inst_VOPC__V_CMPX_NLG_F32 : public Inst_VOPC
23513     {
23514       public:
23515         Inst_VOPC__V_CMPX_NLG_F32(InFmt_VOPC*);
23516         ~Inst_VOPC__V_CMPX_NLG_F32();
23517
23518         int
23519         getNumOperands() override
23520         {
23521             return numDstRegOperands() + numSrcRegOperands();
23522         } // getNumOperands
23523
23524         int numDstRegOperands() override { return 1; }
23525         int numSrcRegOperands() override { return 2; }
23526
23527         int
23528         getOperandSize(int opIdx) override
23529         {
23530             switch (opIdx) {
23531               case 0: //src_0
23532                 return 4;
23533               case 1: //src_1
23534                 return 4;
23535               case 2: //vcc
23536                 return 8;
23537               default:
23538                 fatal("op idx %i out of bounds\n", opIdx);
23539                 return -1;
23540             }
23541         } // getOperandSize
23542
23543         bool
23544         isSrcOperand(int opIdx) override
23545         {
23546             switch (opIdx) {
23547               case 0: //src_0
23548                 return true;
23549               case 1: //src_1
23550                 return true;
23551               default:
23552                 fatal("op idx %i out of bounds\n", opIdx);
23553                 return false;
23554             }
23555         } // isSrcOperand
23556
23557         bool
23558         isDstOperand(int opIdx) override
23559         {
23560             switch (opIdx) {
23561               case 0: //src_0
23562                 return false;
23563               case 1: //src_1
23564                 return false;
23565               default:
23566                 fatal("op idx %i out of bounds\n", opIdx);
23567                 return false;
23568             }
23569         } // isDstOperand
23570
23571         void execute(GPUDynInstPtr) override;
23572     }; // Inst_VOPC__V_CMPX_NLG_F32
23573
23574     class Inst_VOPC__V_CMPX_NGT_F32 : public Inst_VOPC
23575     {
23576       public:
23577         Inst_VOPC__V_CMPX_NGT_F32(InFmt_VOPC*);
23578         ~Inst_VOPC__V_CMPX_NGT_F32();
23579
23580         int
23581         getNumOperands() override
23582         {
23583             return numDstRegOperands() + numSrcRegOperands();
23584         } // getNumOperands
23585
23586         int numDstRegOperands() override { return 1; }
23587         int numSrcRegOperands() override { return 2; }
23588
23589         int
23590         getOperandSize(int opIdx) override
23591         {
23592             switch (opIdx) {
23593               case 0: //src_0
23594                 return 4;
23595               case 1: //src_1
23596                 return 4;
23597               case 2: //vcc
23598                 return 8;
23599               default:
23600                 fatal("op idx %i out of bounds\n", opIdx);
23601                 return -1;
23602             }
23603         } // getOperandSize
23604
23605         bool
23606         isSrcOperand(int opIdx) override
23607         {
23608             switch (opIdx) {
23609               case 0: //src_0
23610                 return true;
23611               case 1: //src_1
23612                 return true;
23613               default:
23614                 fatal("op idx %i out of bounds\n", opIdx);
23615                 return false;
23616             }
23617         } // isSrcOperand
23618
23619         bool
23620         isDstOperand(int opIdx) override
23621         {
23622             switch (opIdx) {
23623               case 0: //src_0
23624                 return false;
23625               case 1: //src_1
23626                 return false;
23627               default:
23628                 fatal("op idx %i out of bounds\n", opIdx);
23629                 return false;
23630             }
23631         } // isDstOperand
23632
23633         void execute(GPUDynInstPtr) override;
23634     }; // Inst_VOPC__V_CMPX_NGT_F32
23635
23636     class Inst_VOPC__V_CMPX_NLE_F32 : public Inst_VOPC
23637     {
23638       public:
23639         Inst_VOPC__V_CMPX_NLE_F32(InFmt_VOPC*);
23640         ~Inst_VOPC__V_CMPX_NLE_F32();
23641
23642         int
23643         getNumOperands() override
23644         {
23645             return numDstRegOperands() + numSrcRegOperands();
23646         } // getNumOperands
23647
23648         int numDstRegOperands() override { return 1; }
23649         int numSrcRegOperands() override { return 2; }
23650
23651         int
23652         getOperandSize(int opIdx) override
23653         {
23654             switch (opIdx) {
23655               case 0: //src_0
23656                 return 4;
23657               case 1: //src_1
23658                 return 4;
23659               case 2: //vcc
23660                 return 8;
23661               default:
23662                 fatal("op idx %i out of bounds\n", opIdx);
23663                 return -1;
23664             }
23665         } // getOperandSize
23666
23667         bool
23668         isSrcOperand(int opIdx) override
23669         {
23670             switch (opIdx) {
23671               case 0: //src_0
23672                 return true;
23673               case 1: //src_1
23674                 return true;
23675               default:
23676                 fatal("op idx %i out of bounds\n", opIdx);
23677                 return false;
23678             }
23679         } // isSrcOperand
23680
23681         bool
23682         isDstOperand(int opIdx) override
23683         {
23684             switch (opIdx) {
23685               case 0: //src_0
23686                 return false;
23687               case 1: //src_1
23688                 return false;
23689               default:
23690                 fatal("op idx %i out of bounds\n", opIdx);
23691                 return false;
23692             }
23693         } // isDstOperand
23694
23695         void execute(GPUDynInstPtr) override;
23696     }; // Inst_VOPC__V_CMPX_NLE_F32
23697
23698     class Inst_VOPC__V_CMPX_NEQ_F32 : public Inst_VOPC
23699     {
23700       public:
23701         Inst_VOPC__V_CMPX_NEQ_F32(InFmt_VOPC*);
23702         ~Inst_VOPC__V_CMPX_NEQ_F32();
23703
23704         int
23705         getNumOperands() override
23706         {
23707             return numDstRegOperands() + numSrcRegOperands();
23708         } // getNumOperands
23709
23710         int numDstRegOperands() override { return 1; }
23711         int numSrcRegOperands() override { return 2; }
23712
23713         int
23714         getOperandSize(int opIdx) override
23715         {
23716             switch (opIdx) {
23717               case 0: //src_0
23718                 return 4;
23719               case 1: //src_1
23720                 return 4;
23721               case 2: //vcc
23722                 return 8;
23723               default:
23724                 fatal("op idx %i out of bounds\n", opIdx);
23725                 return -1;
23726             }
23727         } // getOperandSize
23728
23729         bool
23730         isSrcOperand(int opIdx) override
23731         {
23732             switch (opIdx) {
23733               case 0: //src_0
23734                 return true;
23735               case 1: //src_1
23736                 return true;
23737               default:
23738                 fatal("op idx %i out of bounds\n", opIdx);
23739                 return false;
23740             }
23741         } // isSrcOperand
23742
23743         bool
23744         isDstOperand(int opIdx) override
23745         {
23746             switch (opIdx) {
23747               case 0: //src_0
23748                 return false;
23749               case 1: //src_1
23750                 return false;
23751               default:
23752                 fatal("op idx %i out of bounds\n", opIdx);
23753                 return false;
23754             }
23755         } // isDstOperand
23756
23757         void execute(GPUDynInstPtr) override;
23758     }; // Inst_VOPC__V_CMPX_NEQ_F32
23759
23760     class Inst_VOPC__V_CMPX_NLT_F32 : public Inst_VOPC
23761     {
23762       public:
23763         Inst_VOPC__V_CMPX_NLT_F32(InFmt_VOPC*);
23764         ~Inst_VOPC__V_CMPX_NLT_F32();
23765
23766         int
23767         getNumOperands() override
23768         {
23769             return numDstRegOperands() + numSrcRegOperands();
23770         } // getNumOperands
23771
23772         int numDstRegOperands() override { return 1; }
23773         int numSrcRegOperands() override { return 2; }
23774
23775         int
23776         getOperandSize(int opIdx) override
23777         {
23778             switch (opIdx) {
23779               case 0: //src_0
23780                 return 4;
23781               case 1: //src_1
23782                 return 4;
23783               case 2: //vcc
23784                 return 8;
23785               default:
23786                 fatal("op idx %i out of bounds\n", opIdx);
23787                 return -1;
23788             }
23789         } // getOperandSize
23790
23791         bool
23792         isSrcOperand(int opIdx) override
23793         {
23794             switch (opIdx) {
23795               case 0: //src_0
23796                 return true;
23797               case 1: //src_1
23798                 return true;
23799               default:
23800                 fatal("op idx %i out of bounds\n", opIdx);
23801                 return false;
23802             }
23803         } // isSrcOperand
23804
23805         bool
23806         isDstOperand(int opIdx) override
23807         {
23808             switch (opIdx) {
23809               case 0: //src_0
23810                 return false;
23811               case 1: //src_1
23812                 return false;
23813               default:
23814                 fatal("op idx %i out of bounds\n", opIdx);
23815                 return false;
23816             }
23817         } // isDstOperand
23818
23819         void execute(GPUDynInstPtr) override;
23820     }; // Inst_VOPC__V_CMPX_NLT_F32
23821
23822     class Inst_VOPC__V_CMPX_TRU_F32 : public Inst_VOPC
23823     {
23824       public:
23825         Inst_VOPC__V_CMPX_TRU_F32(InFmt_VOPC*);
23826         ~Inst_VOPC__V_CMPX_TRU_F32();
23827
23828         int
23829         getNumOperands() override
23830         {
23831             return numDstRegOperands() + numSrcRegOperands();
23832         } // getNumOperands
23833
23834         int numDstRegOperands() override { return 1; }
23835         int numSrcRegOperands() override { return 2; }
23836
23837         int
23838         getOperandSize(int opIdx) override
23839         {
23840             switch (opIdx) {
23841               case 0: //src_0
23842                 return 4;
23843               case 1: //src_1
23844                 return 4;
23845               case 2: //vcc
23846                 return 8;
23847               default:
23848                 fatal("op idx %i out of bounds\n", opIdx);
23849                 return -1;
23850             }
23851         } // getOperandSize
23852
23853         bool
23854         isSrcOperand(int opIdx) override
23855         {
23856             switch (opIdx) {
23857               case 0: //src_0
23858                 return true;
23859               case 1: //src_1
23860                 return true;
23861               default:
23862                 fatal("op idx %i out of bounds\n", opIdx);
23863                 return false;
23864             }
23865         } // isSrcOperand
23866
23867         bool
23868         isDstOperand(int opIdx) override
23869         {
23870             switch (opIdx) {
23871               case 0: //src_0
23872                 return false;
23873               case 1: //src_1
23874                 return false;
23875               default:
23876                 fatal("op idx %i out of bounds\n", opIdx);
23877                 return false;
23878             }
23879         } // isDstOperand
23880
23881         void execute(GPUDynInstPtr) override;
23882     }; // Inst_VOPC__V_CMPX_TRU_F32
23883
23884     class Inst_VOPC__V_CMP_F_F64 : public Inst_VOPC
23885     {
23886       public:
23887         Inst_VOPC__V_CMP_F_F64(InFmt_VOPC*);
23888         ~Inst_VOPC__V_CMP_F_F64();
23889
23890         int
23891         getNumOperands() override
23892         {
23893             return numDstRegOperands() + numSrcRegOperands();
23894         } // getNumOperands
23895
23896         int numDstRegOperands() override { return 1; }
23897         int numSrcRegOperands() override { return 2; }
23898
23899         int
23900         getOperandSize(int opIdx) override
23901         {
23902             switch (opIdx) {
23903               case 0: //src_0
23904                 return 8;
23905               case 1: //src_1
23906                 return 8;
23907               case 2: //vcc
23908                 return 8;
23909               default:
23910                 fatal("op idx %i out of bounds\n", opIdx);
23911                 return -1;
23912             }
23913         } // getOperandSize
23914
23915         bool
23916         isSrcOperand(int opIdx) override
23917         {
23918             switch (opIdx) {
23919               case 0: //src_0
23920                 return true;
23921               case 1: //src_1
23922                 return true;
23923               case 2: //vcc
23924                 return false;
23925               default:
23926                 fatal("op idx %i out of bounds\n", opIdx);
23927                 return false;
23928             }
23929         } // isSrcOperand
23930
23931         bool
23932         isDstOperand(int opIdx) override
23933         {
23934             switch (opIdx) {
23935               case 0: //src_0
23936                 return false;
23937               case 1: //src_1
23938                 return false;
23939               case 2: //vcc
23940                 return true;
23941               default:
23942                 fatal("op idx %i out of bounds\n", opIdx);
23943                 return false;
23944             }
23945         } // isDstOperand
23946
23947         void execute(GPUDynInstPtr) override;
23948     }; // Inst_VOPC__V_CMP_F_F64
23949
23950     class Inst_VOPC__V_CMP_LT_F64 : public Inst_VOPC
23951     {
23952       public:
23953         Inst_VOPC__V_CMP_LT_F64(InFmt_VOPC*);
23954         ~Inst_VOPC__V_CMP_LT_F64();
23955
23956         int
23957         getNumOperands() override
23958         {
23959             return numDstRegOperands() + numSrcRegOperands();
23960         } // getNumOperands
23961
23962         int numDstRegOperands() override { return 1; }
23963         int numSrcRegOperands() override { return 2; }
23964
23965         int
23966         getOperandSize(int opIdx) override
23967         {
23968             switch (opIdx) {
23969               case 0: //src_0
23970                 return 8;
23971               case 1: //src_1
23972                 return 8;
23973               case 2: //vcc
23974                 return 8;
23975               default:
23976                 fatal("op idx %i out of bounds\n", opIdx);
23977                 return -1;
23978             }
23979         } // getOperandSize
23980
23981         bool
23982         isSrcOperand(int opIdx) override
23983         {
23984             switch (opIdx) {
23985               case 0: //src_0
23986                 return true;
23987               case 1: //src_1
23988                 return true;
23989               case 2: //vcc
23990                 return false;
23991               default:
23992                 fatal("op idx %i out of bounds\n", opIdx);
23993                 return false;
23994             }
23995         } // isSrcOperand
23996
23997         bool
23998         isDstOperand(int opIdx) override
23999         {
24000             switch (opIdx) {
24001               case 0: //src_0
24002                 return false;
24003               case 1: //src_1
24004                 return false;
24005               case 2: //vcc
24006                 return true;
24007               default:
24008                 fatal("op idx %i out of bounds\n", opIdx);
24009                 return false;
24010             }
24011         } // isDstOperand
24012
24013         void execute(GPUDynInstPtr) override;
24014     }; // Inst_VOPC__V_CMP_LT_F64
24015
24016     class Inst_VOPC__V_CMP_EQ_F64 : public Inst_VOPC
24017     {
24018       public:
24019         Inst_VOPC__V_CMP_EQ_F64(InFmt_VOPC*);
24020         ~Inst_VOPC__V_CMP_EQ_F64();
24021
24022         int
24023         getNumOperands() override
24024         {
24025             return numDstRegOperands() + numSrcRegOperands();
24026         } // getNumOperands
24027
24028         int numDstRegOperands() override { return 1; }
24029         int numSrcRegOperands() override { return 2; }
24030
24031         int
24032         getOperandSize(int opIdx) override
24033         {
24034             switch (opIdx) {
24035               case 0: //src_0
24036                 return 8;
24037               case 1: //src_1
24038                 return 8;
24039               case 2: //vcc
24040                 return 8;
24041               default:
24042                 fatal("op idx %i out of bounds\n", opIdx);
24043                 return -1;
24044             }
24045         } // getOperandSize
24046
24047         bool
24048         isSrcOperand(int opIdx) override
24049         {
24050             switch (opIdx) {
24051               case 0: //src_0
24052                 return true;
24053               case 1: //src_1
24054                 return true;
24055               case 2: //vcc
24056                 return false;
24057               default:
24058                 fatal("op idx %i out of bounds\n", opIdx);
24059                 return false;
24060             }
24061         } // isSrcOperand
24062
24063         bool
24064         isDstOperand(int opIdx) override
24065         {
24066             switch (opIdx) {
24067               case 0: //src_0
24068                 return false;
24069               case 1: //src_1
24070                 return false;
24071               case 2: //vcc
24072                 return true;
24073               default:
24074                 fatal("op idx %i out of bounds\n", opIdx);
24075                 return false;
24076             }
24077         } // isDstOperand
24078
24079         void execute(GPUDynInstPtr) override;
24080     }; // Inst_VOPC__V_CMP_EQ_F64
24081
24082     class Inst_VOPC__V_CMP_LE_F64 : public Inst_VOPC
24083     {
24084       public:
24085         Inst_VOPC__V_CMP_LE_F64(InFmt_VOPC*);
24086         ~Inst_VOPC__V_CMP_LE_F64();
24087
24088         int
24089         getNumOperands() override
24090         {
24091             return numDstRegOperands() + numSrcRegOperands();
24092         } // getNumOperands
24093
24094         int numDstRegOperands() override { return 1; }
24095         int numSrcRegOperands() override { return 2; }
24096
24097         int
24098         getOperandSize(int opIdx) override
24099         {
24100             switch (opIdx) {
24101               case 0: //src_0
24102                 return 8;
24103               case 1: //src_1
24104                 return 8;
24105               case 2: //vcc
24106                 return 8;
24107               default:
24108                 fatal("op idx %i out of bounds\n", opIdx);
24109                 return -1;
24110             }
24111         } // getOperandSize
24112
24113         bool
24114         isSrcOperand(int opIdx) override
24115         {
24116             switch (opIdx) {
24117               case 0: //src_0
24118                 return true;
24119               case 1: //src_1
24120                 return true;
24121               case 2: //vcc
24122                 return false;
24123               default:
24124                 fatal("op idx %i out of bounds\n", opIdx);
24125                 return false;
24126             }
24127         } // isSrcOperand
24128
24129         bool
24130         isDstOperand(int opIdx) override
24131         {
24132             switch (opIdx) {
24133               case 0: //src_0
24134                 return false;
24135               case 1: //src_1
24136                 return false;
24137               case 2: //vcc
24138                 return true;
24139               default:
24140                 fatal("op idx %i out of bounds\n", opIdx);
24141                 return false;
24142             }
24143         } // isDstOperand
24144
24145         void execute(GPUDynInstPtr) override;
24146     }; // Inst_VOPC__V_CMP_LE_F64
24147
24148     class Inst_VOPC__V_CMP_GT_F64 : public Inst_VOPC
24149     {
24150       public:
24151         Inst_VOPC__V_CMP_GT_F64(InFmt_VOPC*);
24152         ~Inst_VOPC__V_CMP_GT_F64();
24153
24154         int
24155         getNumOperands() override
24156         {
24157             return numDstRegOperands() + numSrcRegOperands();
24158         } // getNumOperands
24159
24160         int numDstRegOperands() override { return 1; }
24161         int numSrcRegOperands() override { return 2; }
24162
24163         int
24164         getOperandSize(int opIdx) override
24165         {
24166             switch (opIdx) {
24167               case 0: //src_0
24168                 return 8;
24169               case 1: //src_1
24170                 return 8;
24171               case 2: //vcc
24172                 return 8;
24173               default:
24174                 fatal("op idx %i out of bounds\n", opIdx);
24175                 return -1;
24176             }
24177         } // getOperandSize
24178
24179         bool
24180         isSrcOperand(int opIdx) override
24181         {
24182             switch (opIdx) {
24183               case 0: //src_0
24184                 return true;
24185               case 1: //src_1
24186                 return true;
24187               case 2: //vcc
24188                 return false;
24189               default:
24190                 fatal("op idx %i out of bounds\n", opIdx);
24191                 return false;
24192             }
24193         } // isSrcOperand
24194
24195         bool
24196         isDstOperand(int opIdx) override
24197         {
24198             switch (opIdx) {
24199               case 0: //src_0
24200                 return false;
24201               case 1: //src_1
24202                 return false;
24203               case 2: //vcc
24204                 return true;
24205               default:
24206                 fatal("op idx %i out of bounds\n", opIdx);
24207                 return false;
24208             }
24209         } // isDstOperand
24210
24211         void execute(GPUDynInstPtr) override;
24212     }; // Inst_VOPC__V_CMP_GT_F64
24213
24214     class Inst_VOPC__V_CMP_LG_F64 : public Inst_VOPC
24215     {
24216       public:
24217         Inst_VOPC__V_CMP_LG_F64(InFmt_VOPC*);
24218         ~Inst_VOPC__V_CMP_LG_F64();
24219
24220         int
24221         getNumOperands() override
24222         {
24223             return numDstRegOperands() + numSrcRegOperands();
24224         } // getNumOperands
24225
24226         int numDstRegOperands() override { return 1; }
24227         int numSrcRegOperands() override { return 2; }
24228
24229         int
24230         getOperandSize(int opIdx) override
24231         {
24232             switch (opIdx) {
24233               case 0: //src_0
24234                 return 8;
24235               case 1: //src_1
24236                 return 8;
24237               case 2: //vcc
24238                 return 8;
24239               default:
24240                 fatal("op idx %i out of bounds\n", opIdx);
24241                 return -1;
24242             }
24243         } // getOperandSize
24244
24245         bool
24246         isSrcOperand(int opIdx) override
24247         {
24248             switch (opIdx) {
24249               case 0: //src_0
24250                 return true;
24251               case 1: //src_1
24252                 return true;
24253               case 2: //vcc
24254                 return false;
24255               default:
24256                 fatal("op idx %i out of bounds\n", opIdx);
24257                 return false;
24258             }
24259         } // isSrcOperand
24260
24261         bool
24262         isDstOperand(int opIdx) override
24263         {
24264             switch (opIdx) {
24265               case 0: //src_0
24266                 return false;
24267               case 1: //src_1
24268                 return false;
24269               case 2: //vcc
24270                 return true;
24271               default:
24272                 fatal("op idx %i out of bounds\n", opIdx);
24273                 return false;
24274             }
24275         } // isDstOperand
24276
24277         void execute(GPUDynInstPtr) override;
24278     }; // Inst_VOPC__V_CMP_LG_F64
24279
24280     class Inst_VOPC__V_CMP_GE_F64 : public Inst_VOPC
24281     {
24282       public:
24283         Inst_VOPC__V_CMP_GE_F64(InFmt_VOPC*);
24284         ~Inst_VOPC__V_CMP_GE_F64();
24285
24286         int
24287         getNumOperands() override
24288         {
24289             return numDstRegOperands() + numSrcRegOperands();
24290         } // getNumOperands
24291
24292         int numDstRegOperands() override { return 1; }
24293         int numSrcRegOperands() override { return 2; }
24294
24295         int
24296         getOperandSize(int opIdx) override
24297         {
24298             switch (opIdx) {
24299               case 0: //src_0
24300                 return 8;
24301               case 1: //src_1
24302                 return 8;
24303               case 2: //vcc
24304                 return 8;
24305               default:
24306                 fatal("op idx %i out of bounds\n", opIdx);
24307                 return -1;
24308             }
24309         } // getOperandSize
24310
24311         bool
24312         isSrcOperand(int opIdx) override
24313         {
24314             switch (opIdx) {
24315               case 0: //src_0
24316                 return true;
24317               case 1: //src_1
24318                 return true;
24319               case 2: //vcc
24320                 return false;
24321               default:
24322                 fatal("op idx %i out of bounds\n", opIdx);
24323                 return false;
24324             }
24325         } // isSrcOperand
24326
24327         bool
24328         isDstOperand(int opIdx) override
24329         {
24330             switch (opIdx) {
24331               case 0: //src_0
24332                 return false;
24333               case 1: //src_1
24334                 return false;
24335               case 2: //vcc
24336                 return true;
24337               default:
24338                 fatal("op idx %i out of bounds\n", opIdx);
24339                 return false;
24340             }
24341         } // isDstOperand
24342
24343         void execute(GPUDynInstPtr) override;
24344     }; // Inst_VOPC__V_CMP_GE_F64
24345
24346     class Inst_VOPC__V_CMP_O_F64 : public Inst_VOPC
24347     {
24348       public:
24349         Inst_VOPC__V_CMP_O_F64(InFmt_VOPC*);
24350         ~Inst_VOPC__V_CMP_O_F64();
24351
24352         int
24353         getNumOperands() override
24354         {
24355             return numDstRegOperands() + numSrcRegOperands();
24356         } // getNumOperands
24357
24358         int numDstRegOperands() override { return 1; }
24359         int numSrcRegOperands() override { return 2; }
24360
24361         int
24362         getOperandSize(int opIdx) override
24363         {
24364             switch (opIdx) {
24365               case 0: //src_0
24366                 return 8;
24367               case 1: //src_1
24368                 return 8;
24369               case 2: //vcc
24370                 return 8;
24371               default:
24372                 fatal("op idx %i out of bounds\n", opIdx);
24373                 return -1;
24374             }
24375         } // getOperandSize
24376
24377         bool
24378         isSrcOperand(int opIdx) override
24379         {
24380             switch (opIdx) {
24381               case 0: //src_0
24382                 return true;
24383               case 1: //src_1
24384                 return true;
24385               case 2: //vcc
24386                 return false;
24387               default:
24388                 fatal("op idx %i out of bounds\n", opIdx);
24389                 return false;
24390             }
24391         } // isSrcOperand
24392
24393         bool
24394         isDstOperand(int opIdx) override
24395         {
24396             switch (opIdx) {
24397               case 0: //src_0
24398                 return false;
24399               case 1: //src_1
24400                 return false;
24401               case 2: //vcc
24402                 return true;
24403               default:
24404                 fatal("op idx %i out of bounds\n", opIdx);
24405                 return false;
24406             }
24407         } // isDstOperand
24408
24409         void execute(GPUDynInstPtr) override;
24410     }; // Inst_VOPC__V_CMP_O_F64
24411
24412     class Inst_VOPC__V_CMP_U_F64 : public Inst_VOPC
24413     {
24414       public:
24415         Inst_VOPC__V_CMP_U_F64(InFmt_VOPC*);
24416         ~Inst_VOPC__V_CMP_U_F64();
24417
24418         int
24419         getNumOperands() override
24420         {
24421             return numDstRegOperands() + numSrcRegOperands();
24422         } // getNumOperands
24423
24424         int numDstRegOperands() override { return 1; }
24425         int numSrcRegOperands() override { return 2; }
24426
24427         int
24428         getOperandSize(int opIdx) override
24429         {
24430             switch (opIdx) {
24431               case 0: //src_0
24432                 return 8;
24433               case 1: //src_1
24434                 return 8;
24435               case 2: //vcc
24436                 return 8;
24437               default:
24438                 fatal("op idx %i out of bounds\n", opIdx);
24439                 return -1;
24440             }
24441         } // getOperandSize
24442
24443         bool
24444         isSrcOperand(int opIdx) override
24445         {
24446             switch (opIdx) {
24447               case 0: //src_0
24448                 return true;
24449               case 1: //src_1
24450                 return true;
24451               case 2: //vcc
24452                 return false;
24453               default:
24454                 fatal("op idx %i out of bounds\n", opIdx);
24455                 return false;
24456             }
24457         } // isSrcOperand
24458
24459         bool
24460         isDstOperand(int opIdx) override
24461         {
24462             switch (opIdx) {
24463               case 0: //src_0
24464                 return false;
24465               case 1: //src_1
24466                 return false;
24467               case 2: //vcc
24468                 return true;
24469               default:
24470                 fatal("op idx %i out of bounds\n", opIdx);
24471                 return false;
24472             }
24473         } // isDstOperand
24474
24475         void execute(GPUDynInstPtr) override;
24476     }; // Inst_VOPC__V_CMP_U_F64
24477
24478     class Inst_VOPC__V_CMP_NGE_F64 : public Inst_VOPC
24479     {
24480       public:
24481         Inst_VOPC__V_CMP_NGE_F64(InFmt_VOPC*);
24482         ~Inst_VOPC__V_CMP_NGE_F64();
24483
24484         int
24485         getNumOperands() override
24486         {
24487             return numDstRegOperands() + numSrcRegOperands();
24488         } // getNumOperands
24489
24490         int numDstRegOperands() override { return 1; }
24491         int numSrcRegOperands() override { return 2; }
24492
24493         int
24494         getOperandSize(int opIdx) override
24495         {
24496             switch (opIdx) {
24497               case 0: //src_0
24498                 return 8;
24499               case 1: //src_1
24500                 return 8;
24501               case 2: //vcc
24502                 return 8;
24503               default:
24504                 fatal("op idx %i out of bounds\n", opIdx);
24505                 return -1;
24506             }
24507         } // getOperandSize
24508
24509         bool
24510         isSrcOperand(int opIdx) override
24511         {
24512             switch (opIdx) {
24513               case 0: //src_0
24514                 return true;
24515               case 1: //src_1
24516                 return true;
24517               case 2: //vcc
24518                 return false;
24519               default:
24520                 fatal("op idx %i out of bounds\n", opIdx);
24521                 return false;
24522             }
24523         } // isSrcOperand
24524
24525         bool
24526         isDstOperand(int opIdx) override
24527         {
24528             switch (opIdx) {
24529               case 0: //src_0
24530                 return false;
24531               case 1: //src_1
24532                 return false;
24533               case 2: //vcc
24534                 return true;
24535               default:
24536                 fatal("op idx %i out of bounds\n", opIdx);
24537                 return false;
24538             }
24539         } // isDstOperand
24540
24541         void execute(GPUDynInstPtr) override;
24542     }; // Inst_VOPC__V_CMP_NGE_F64
24543
24544     class Inst_VOPC__V_CMP_NLG_F64 : public Inst_VOPC
24545     {
24546       public:
24547         Inst_VOPC__V_CMP_NLG_F64(InFmt_VOPC*);
24548         ~Inst_VOPC__V_CMP_NLG_F64();
24549
24550         int
24551         getNumOperands() override
24552         {
24553             return numDstRegOperands() + numSrcRegOperands();
24554         } // getNumOperands
24555
24556         int numDstRegOperands() override { return 1; }
24557         int numSrcRegOperands() override { return 2; }
24558
24559         int
24560         getOperandSize(int opIdx) override
24561         {
24562             switch (opIdx) {
24563               case 0: //src_0
24564                 return 8;
24565               case 1: //src_1
24566                 return 8;
24567               case 2: //vcc
24568                 return 8;
24569               default:
24570                 fatal("op idx %i out of bounds\n", opIdx);
24571                 return -1;
24572             }
24573         } // getOperandSize
24574
24575         bool
24576         isSrcOperand(int opIdx) override
24577         {
24578             switch (opIdx) {
24579               case 0: //src_0
24580                 return true;
24581               case 1: //src_1
24582                 return true;
24583               case 2: //vcc
24584                 return false;
24585               default:
24586                 fatal("op idx %i out of bounds\n", opIdx);
24587                 return false;
24588             }
24589         } // isSrcOperand
24590
24591         bool
24592         isDstOperand(int opIdx) override
24593         {
24594             switch (opIdx) {
24595               case 0: //src_0
24596                 return false;
24597               case 1: //src_1
24598                 return false;
24599               case 2: //vcc
24600                 return true;
24601               default:
24602                 fatal("op idx %i out of bounds\n", opIdx);
24603                 return false;
24604             }
24605         } // isDstOperand
24606
24607         void execute(GPUDynInstPtr) override;
24608     }; // Inst_VOPC__V_CMP_NLG_F64
24609
24610     class Inst_VOPC__V_CMP_NGT_F64 : public Inst_VOPC
24611     {
24612       public:
24613         Inst_VOPC__V_CMP_NGT_F64(InFmt_VOPC*);
24614         ~Inst_VOPC__V_CMP_NGT_F64();
24615
24616         int
24617         getNumOperands() override
24618         {
24619             return numDstRegOperands() + numSrcRegOperands();
24620         } // getNumOperands
24621
24622         int numDstRegOperands() override { return 1; }
24623         int numSrcRegOperands() override { return 2; }
24624
24625         int
24626         getOperandSize(int opIdx) override
24627         {
24628             switch (opIdx) {
24629               case 0: //src_0
24630                 return 8;
24631               case 1: //src_1
24632                 return 8;
24633               case 2: //vcc
24634                 return 8;
24635               default:
24636                 fatal("op idx %i out of bounds\n", opIdx);
24637                 return -1;
24638             }
24639         } // getOperandSize
24640
24641         bool
24642         isSrcOperand(int opIdx) override
24643         {
24644             switch (opIdx) {
24645               case 0: //src_0
24646                 return true;
24647               case 1: //src_1
24648                 return true;
24649               case 2: //vcc
24650                 return false;
24651               default:
24652                 fatal("op idx %i out of bounds\n", opIdx);
24653                 return false;
24654             }
24655         } // isSrcOperand
24656
24657         bool
24658         isDstOperand(int opIdx) override
24659         {
24660             switch (opIdx) {
24661               case 0: //src_0
24662                 return false;
24663               case 1: //src_1
24664                 return false;
24665               case 2: //vcc
24666                 return true;
24667               default:
24668                 fatal("op idx %i out of bounds\n", opIdx);
24669                 return false;
24670             }
24671         } // isDstOperand
24672
24673         void execute(GPUDynInstPtr) override;
24674     }; // Inst_VOPC__V_CMP_NGT_F64
24675
24676     class Inst_VOPC__V_CMP_NLE_F64 : public Inst_VOPC
24677     {
24678       public:
24679         Inst_VOPC__V_CMP_NLE_F64(InFmt_VOPC*);
24680         ~Inst_VOPC__V_CMP_NLE_F64();
24681
24682         int
24683         getNumOperands() override
24684         {
24685             return numDstRegOperands() + numSrcRegOperands();
24686         } // getNumOperands
24687
24688         int numDstRegOperands() override { return 1; }
24689         int numSrcRegOperands() override { return 2; }
24690
24691         int
24692         getOperandSize(int opIdx) override
24693         {
24694             switch (opIdx) {
24695               case 0: //src_0
24696                 return 8;
24697               case 1: //src_1
24698                 return 8;
24699               case 2: //vcc
24700                 return 8;
24701               default:
24702                 fatal("op idx %i out of bounds\n", opIdx);
24703                 return -1;
24704             }
24705         } // getOperandSize
24706
24707         bool
24708         isSrcOperand(int opIdx) override
24709         {
24710             switch (opIdx) {
24711               case 0: //src_0
24712                 return true;
24713               case 1: //src_1
24714                 return true;
24715               case 2: //vcc
24716                 return false;
24717               default:
24718                 fatal("op idx %i out of bounds\n", opIdx);
24719                 return false;
24720             }
24721         } // isSrcOperand
24722
24723         bool
24724         isDstOperand(int opIdx) override
24725         {
24726             switch (opIdx) {
24727               case 0: //src_0
24728                 return false;
24729               case 1: //src_1
24730                 return false;
24731               case 2: //vcc
24732                 return true;
24733               default:
24734                 fatal("op idx %i out of bounds\n", opIdx);
24735                 return false;
24736             }
24737         } // isDstOperand
24738
24739         void execute(GPUDynInstPtr) override;
24740     }; // Inst_VOPC__V_CMP_NLE_F64
24741
24742     class Inst_VOPC__V_CMP_NEQ_F64 : public Inst_VOPC
24743     {
24744       public:
24745         Inst_VOPC__V_CMP_NEQ_F64(InFmt_VOPC*);
24746         ~Inst_VOPC__V_CMP_NEQ_F64();
24747
24748         int
24749         getNumOperands() override
24750         {
24751             return numDstRegOperands() + numSrcRegOperands();
24752         } // getNumOperands
24753
24754         int numDstRegOperands() override { return 1; }
24755         int numSrcRegOperands() override { return 2; }
24756
24757         int
24758         getOperandSize(int opIdx) override
24759         {
24760             switch (opIdx) {
24761               case 0: //src_0
24762                 return 8;
24763               case 1: //src_1
24764                 return 8;
24765               case 2: //vcc
24766                 return 8;
24767               default:
24768                 fatal("op idx %i out of bounds\n", opIdx);
24769                 return -1;
24770             }
24771         } // getOperandSize
24772
24773         bool
24774         isSrcOperand(int opIdx) override
24775         {
24776             switch (opIdx) {
24777               case 0: //src_0
24778                 return true;
24779               case 1: //src_1
24780                 return true;
24781               case 2: //vcc
24782                 return false;
24783               default:
24784                 fatal("op idx %i out of bounds\n", opIdx);
24785                 return false;
24786             }
24787         } // isSrcOperand
24788
24789         bool
24790         isDstOperand(int opIdx) override
24791         {
24792             switch (opIdx) {
24793               case 0: //src_0
24794                 return false;
24795               case 1: //src_1
24796                 return false;
24797               case 2: //vcc
24798                 return true;
24799               default:
24800                 fatal("op idx %i out of bounds\n", opIdx);
24801                 return false;
24802             }
24803         } // isDstOperand
24804
24805         void execute(GPUDynInstPtr) override;
24806     }; // Inst_VOPC__V_CMP_NEQ_F64
24807
24808     class Inst_VOPC__V_CMP_NLT_F64 : public Inst_VOPC
24809     {
24810       public:
24811         Inst_VOPC__V_CMP_NLT_F64(InFmt_VOPC*);
24812         ~Inst_VOPC__V_CMP_NLT_F64();
24813
24814         int
24815         getNumOperands() override
24816         {
24817             return numDstRegOperands() + numSrcRegOperands();
24818         } // getNumOperands
24819
24820         int numDstRegOperands() override { return 1; }
24821         int numSrcRegOperands() override { return 2; }
24822
24823         int
24824         getOperandSize(int opIdx) override
24825         {
24826             switch (opIdx) {
24827               case 0: //src_0
24828                 return 8;
24829               case 1: //src_1
24830                 return 8;
24831               case 2: //vcc
24832                 return 8;
24833               default:
24834                 fatal("op idx %i out of bounds\n", opIdx);
24835                 return -1;
24836             }
24837         } // getOperandSize
24838
24839         bool
24840         isSrcOperand(int opIdx) override
24841         {
24842             switch (opIdx) {
24843               case 0: //src_0
24844                 return true;
24845               case 1: //src_1
24846                 return true;
24847               case 2: //vcc
24848                 return false;
24849               default:
24850                 fatal("op idx %i out of bounds\n", opIdx);
24851                 return false;
24852             }
24853         } // isSrcOperand
24854
24855         bool
24856         isDstOperand(int opIdx) override
24857         {
24858             switch (opIdx) {
24859               case 0: //src_0
24860                 return false;
24861               case 1: //src_1
24862                 return false;
24863               case 2: //vcc
24864                 return true;
24865               default:
24866                 fatal("op idx %i out of bounds\n", opIdx);
24867                 return false;
24868             }
24869         } // isDstOperand
24870
24871         void execute(GPUDynInstPtr) override;
24872     }; // Inst_VOPC__V_CMP_NLT_F64
24873
24874     class Inst_VOPC__V_CMP_TRU_F64 : public Inst_VOPC
24875     {
24876       public:
24877         Inst_VOPC__V_CMP_TRU_F64(InFmt_VOPC*);
24878         ~Inst_VOPC__V_CMP_TRU_F64();
24879
24880         int
24881         getNumOperands() override
24882         {
24883             return numDstRegOperands() + numSrcRegOperands();
24884         } // getNumOperands
24885
24886         int numDstRegOperands() override { return 1; }
24887         int numSrcRegOperands() override { return 2; }
24888
24889         int
24890         getOperandSize(int opIdx) override
24891         {
24892             switch (opIdx) {
24893               case 0: //src_0
24894                 return 8;
24895               case 1: //src_1
24896                 return 8;
24897               case 2: //vcc
24898                 return 8;
24899               default:
24900                 fatal("op idx %i out of bounds\n", opIdx);
24901                 return -1;
24902             }
24903         } // getOperandSize
24904
24905         bool
24906         isSrcOperand(int opIdx) override
24907         {
24908             switch (opIdx) {
24909               case 0: //src_0
24910                 return true;
24911               case 1: //src_1
24912                 return true;
24913               default:
24914                 fatal("op idx %i out of bounds\n", opIdx);
24915                 return false;
24916             }
24917         } // isSrcOperand
24918
24919         bool
24920         isDstOperand(int opIdx) override
24921         {
24922             switch (opIdx) {
24923               case 0: //src_0
24924                 return false;
24925               case 1: //src_1
24926                 return false;
24927               default:
24928                 fatal("op idx %i out of bounds\n", opIdx);
24929                 return false;
24930             }
24931         } // isDstOperand
24932
24933         void execute(GPUDynInstPtr) override;
24934     }; // Inst_VOPC__V_CMP_TRU_F64
24935
24936     class Inst_VOPC__V_CMPX_F_F64 : public Inst_VOPC
24937     {
24938       public:
24939         Inst_VOPC__V_CMPX_F_F64(InFmt_VOPC*);
24940         ~Inst_VOPC__V_CMPX_F_F64();
24941
24942         int
24943         getNumOperands() override
24944         {
24945             return numDstRegOperands() + numSrcRegOperands();
24946         } // getNumOperands
24947
24948         int numDstRegOperands() override { return 1; }
24949         int numSrcRegOperands() override { return 2; }
24950
24951         int
24952         getOperandSize(int opIdx) override
24953         {
24954             switch (opIdx) {
24955               case 0: //src_0
24956                 return 8;
24957               case 1: //src_1
24958                 return 8;
24959               case 2: //vcc
24960                 return 8;
24961               default:
24962                 fatal("op idx %i out of bounds\n", opIdx);
24963                 return -1;
24964             }
24965         } // getOperandSize
24966
24967         bool
24968         isSrcOperand(int opIdx) override
24969         {
24970             switch (opIdx) {
24971               case 0: //src_0
24972                 return true;
24973               case 1: //src_1
24974                 return true;
24975               default:
24976                 fatal("op idx %i out of bounds\n", opIdx);
24977                 return false;
24978             }
24979         } // isSrcOperand
24980
24981         bool
24982         isDstOperand(int opIdx) override
24983         {
24984             switch (opIdx) {
24985               case 0: //src_0
24986                 return false;
24987               case 1: //src_1
24988                 return false;
24989               default:
24990                 fatal("op idx %i out of bounds\n", opIdx);
24991                 return false;
24992             }
24993         } // isDstOperand
24994
24995         void execute(GPUDynInstPtr) override;
24996     }; // Inst_VOPC__V_CMPX_F_F64
24997
24998     class Inst_VOPC__V_CMPX_LT_F64 : public Inst_VOPC
24999     {
25000       public:
25001         Inst_VOPC__V_CMPX_LT_F64(InFmt_VOPC*);
25002         ~Inst_VOPC__V_CMPX_LT_F64();
25003
25004         int
25005         getNumOperands() override
25006         {
25007             return numDstRegOperands() + numSrcRegOperands();
25008         } // getNumOperands
25009
25010         int numDstRegOperands() override { return 1; }
25011         int numSrcRegOperands() override { return 2; }
25012
25013         int
25014         getOperandSize(int opIdx) override
25015         {
25016             switch (opIdx) {
25017               case 0: //src_0
25018                 return 8;
25019               case 1: //src_1
25020                 return 8;
25021               case 2: //vcc
25022                 return 8;
25023               default:
25024                 fatal("op idx %i out of bounds\n", opIdx);
25025                 return -1;
25026             }
25027         } // getOperandSize
25028
25029         bool
25030         isSrcOperand(int opIdx) override
25031         {
25032             switch (opIdx) {
25033               case 0: //src_0
25034                 return true;
25035               case 1: //src_1
25036                 return true;
25037               default:
25038                 fatal("op idx %i out of bounds\n", opIdx);
25039                 return false;
25040             }
25041         } // isSrcOperand
25042
25043         bool
25044         isDstOperand(int opIdx) override
25045         {
25046             switch (opIdx) {
25047               case 0: //src_0
25048                 return false;
25049               case 1: //src_1
25050                 return false;
25051               default:
25052                 fatal("op idx %i out of bounds\n", opIdx);
25053                 return false;
25054             }
25055         } // isDstOperand
25056
25057         void execute(GPUDynInstPtr) override;
25058     }; // Inst_VOPC__V_CMPX_LT_F64
25059
25060     class Inst_VOPC__V_CMPX_EQ_F64 : public Inst_VOPC
25061     {
25062       public:
25063         Inst_VOPC__V_CMPX_EQ_F64(InFmt_VOPC*);
25064         ~Inst_VOPC__V_CMPX_EQ_F64();
25065
25066         int
25067         getNumOperands() override
25068         {
25069             return numDstRegOperands() + numSrcRegOperands();
25070         } // getNumOperands
25071
25072         int numDstRegOperands() override { return 1; }
25073         int numSrcRegOperands() override { return 2; }
25074
25075         int
25076         getOperandSize(int opIdx) override
25077         {
25078             switch (opIdx) {
25079               case 0: //src_0
25080                 return 8;
25081               case 1: //src_1
25082                 return 8;
25083               case 2: //vcc
25084                 return 8;
25085               default:
25086                 fatal("op idx %i out of bounds\n", opIdx);
25087                 return -1;
25088             }
25089         } // getOperandSize
25090
25091         bool
25092         isSrcOperand(int opIdx) override
25093         {
25094             switch (opIdx) {
25095               case 0: //src_0
25096                 return true;
25097               case 1: //src_1
25098                 return true;
25099               default:
25100                 fatal("op idx %i out of bounds\n", opIdx);
25101                 return false;
25102             }
25103         } // isSrcOperand
25104
25105         bool
25106         isDstOperand(int opIdx) override
25107         {
25108             switch (opIdx) {
25109               case 0: //src_0
25110                 return false;
25111               case 1: //src_1
25112                 return false;
25113               default:
25114                 fatal("op idx %i out of bounds\n", opIdx);
25115                 return false;
25116             }
25117         } // isDstOperand
25118
25119         void execute(GPUDynInstPtr) override;
25120     }; // Inst_VOPC__V_CMPX_EQ_F64
25121
25122     class Inst_VOPC__V_CMPX_LE_F64 : public Inst_VOPC
25123     {
25124       public:
25125         Inst_VOPC__V_CMPX_LE_F64(InFmt_VOPC*);
25126         ~Inst_VOPC__V_CMPX_LE_F64();
25127
25128         int
25129         getNumOperands() override
25130         {
25131             return numDstRegOperands() + numSrcRegOperands();
25132         } // getNumOperands
25133
25134         int numDstRegOperands() override { return 1; }
25135         int numSrcRegOperands() override { return 2; }
25136
25137         int
25138         getOperandSize(int opIdx) override
25139         {
25140             switch (opIdx) {
25141               case 0: //src_0
25142                 return 8;
25143               case 1: //src_1
25144                 return 8;
25145               case 2: //vcc
25146                 return 8;
25147               default:
25148                 fatal("op idx %i out of bounds\n", opIdx);
25149                 return -1;
25150             }
25151         } // getOperandSize
25152
25153         bool
25154         isSrcOperand(int opIdx) override
25155         {
25156             switch (opIdx) {
25157               case 0: //src_0
25158                 return true;
25159               case 1: //src_1
25160                 return true;
25161               default:
25162                 fatal("op idx %i out of bounds\n", opIdx);
25163                 return false;
25164             }
25165         } // isSrcOperand
25166
25167         bool
25168         isDstOperand(int opIdx) override
25169         {
25170             switch (opIdx) {
25171               case 0: //src_0
25172                 return false;
25173               case 1: //src_1
25174                 return false;
25175               default:
25176                 fatal("op idx %i out of bounds\n", opIdx);
25177                 return false;
25178             }
25179         } // isDstOperand
25180
25181         void execute(GPUDynInstPtr) override;
25182     }; // Inst_VOPC__V_CMPX_LE_F64
25183
25184     class Inst_VOPC__V_CMPX_GT_F64 : public Inst_VOPC
25185     {
25186       public:
25187         Inst_VOPC__V_CMPX_GT_F64(InFmt_VOPC*);
25188         ~Inst_VOPC__V_CMPX_GT_F64();
25189
25190         int
25191         getNumOperands() override
25192         {
25193             return numDstRegOperands() + numSrcRegOperands();
25194         } // getNumOperands
25195
25196         int numDstRegOperands() override { return 1; }
25197         int numSrcRegOperands() override { return 2; }
25198
25199         int
25200         getOperandSize(int opIdx) override
25201         {
25202             switch (opIdx) {
25203               case 0: //src_0
25204                 return 8;
25205               case 1: //src_1
25206                 return 8;
25207               case 2: //vcc
25208                 return 8;
25209               default:
25210                 fatal("op idx %i out of bounds\n", opIdx);
25211                 return -1;
25212             }
25213         } // getOperandSize
25214
25215         bool
25216         isSrcOperand(int opIdx) override
25217         {
25218             switch (opIdx) {
25219               case 0: //src_0
25220                 return true;
25221               case 1: //src_1
25222                 return true;
25223               default:
25224                 fatal("op idx %i out of bounds\n", opIdx);
25225                 return false;
25226             }
25227         } // isSrcOperand
25228
25229         bool
25230         isDstOperand(int opIdx) override
25231         {
25232             switch (opIdx) {
25233               case 0: //src_0
25234                 return false;
25235               case 1: //src_1
25236                 return false;
25237               default:
25238                 fatal("op idx %i out of bounds\n", opIdx);
25239                 return false;
25240             }
25241         } // isDstOperand
25242
25243         void execute(GPUDynInstPtr) override;
25244     }; // Inst_VOPC__V_CMPX_GT_F64
25245
25246     class Inst_VOPC__V_CMPX_LG_F64 : public Inst_VOPC
25247     {
25248       public:
25249         Inst_VOPC__V_CMPX_LG_F64(InFmt_VOPC*);
25250         ~Inst_VOPC__V_CMPX_LG_F64();
25251
25252         int
25253         getNumOperands() override
25254         {
25255             return numDstRegOperands() + numSrcRegOperands();
25256         } // getNumOperands
25257
25258         int numDstRegOperands() override { return 1; }
25259         int numSrcRegOperands() override { return 2; }
25260
25261         int
25262         getOperandSize(int opIdx) override
25263         {
25264             switch (opIdx) {
25265               case 0: //src_0
25266                 return 8;
25267               case 1: //src_1
25268                 return 8;
25269               case 2: //vcc
25270                 return 8;
25271               default:
25272                 fatal("op idx %i out of bounds\n", opIdx);
25273                 return -1;
25274             }
25275         } // getOperandSize
25276
25277         bool
25278         isSrcOperand(int opIdx) override
25279         {
25280             switch (opIdx) {
25281               case 0: //src_0
25282                 return true;
25283               case 1: //src_1
25284                 return true;
25285               default:
25286                 fatal("op idx %i out of bounds\n", opIdx);
25287                 return false;
25288             }
25289         } // isSrcOperand
25290
25291         bool
25292         isDstOperand(int opIdx) override
25293         {
25294             switch (opIdx) {
25295               case 0: //src_0
25296                 return false;
25297               case 1: //src_1
25298                 return false;
25299               default:
25300                 fatal("op idx %i out of bounds\n", opIdx);
25301                 return false;
25302             }
25303         } // isDstOperand
25304
25305         void execute(GPUDynInstPtr) override;
25306     }; // Inst_VOPC__V_CMPX_LG_F64
25307
25308     class Inst_VOPC__V_CMPX_GE_F64 : public Inst_VOPC
25309     {
25310       public:
25311         Inst_VOPC__V_CMPX_GE_F64(InFmt_VOPC*);
25312         ~Inst_VOPC__V_CMPX_GE_F64();
25313
25314         int
25315         getNumOperands() override
25316         {
25317             return numDstRegOperands() + numSrcRegOperands();
25318         } // getNumOperands
25319
25320         int numDstRegOperands() override { return 1; }
25321         int numSrcRegOperands() override { return 2; }
25322
25323         int
25324         getOperandSize(int opIdx) override
25325         {
25326             switch (opIdx) {
25327               case 0: //src_0
25328                 return 8;
25329               case 1: //src_1
25330                 return 8;
25331               case 2: //vcc
25332                 return 8;
25333               default:
25334                 fatal("op idx %i out of bounds\n", opIdx);
25335                 return -1;
25336             }
25337         } // getOperandSize
25338
25339         bool
25340         isSrcOperand(int opIdx) override
25341         {
25342             switch (opIdx) {
25343               case 0: //src_0
25344                 return true;
25345               case 1: //src_1
25346                 return true;
25347               default:
25348                 fatal("op idx %i out of bounds\n", opIdx);
25349                 return false;
25350             }
25351         } // isSrcOperand
25352
25353         bool
25354         isDstOperand(int opIdx) override
25355         {
25356             switch (opIdx) {
25357               case 0: //src_0
25358                 return false;
25359               case 1: //src_1
25360                 return false;
25361               default:
25362                 fatal("op idx %i out of bounds\n", opIdx);
25363                 return false;
25364             }
25365         } // isDstOperand
25366
25367         void execute(GPUDynInstPtr) override;
25368     }; // Inst_VOPC__V_CMPX_GE_F64
25369
25370     class Inst_VOPC__V_CMPX_O_F64 : public Inst_VOPC
25371     {
25372       public:
25373         Inst_VOPC__V_CMPX_O_F64(InFmt_VOPC*);
25374         ~Inst_VOPC__V_CMPX_O_F64();
25375
25376         int
25377         getNumOperands() override
25378         {
25379             return numDstRegOperands() + numSrcRegOperands();
25380         } // getNumOperands
25381
25382         int numDstRegOperands() override { return 1; }
25383         int numSrcRegOperands() override { return 2; }
25384
25385         int
25386         getOperandSize(int opIdx) override
25387         {
25388             switch (opIdx) {
25389               case 0: //src_0
25390                 return 8;
25391               case 1: //src_1
25392                 return 8;
25393               case 2: //vcc
25394                 return 8;
25395               default:
25396                 fatal("op idx %i out of bounds\n", opIdx);
25397                 return -1;
25398             }
25399         } // getOperandSize
25400
25401         bool
25402         isSrcOperand(int opIdx) override
25403         {
25404             switch (opIdx) {
25405               case 0: //src_0
25406                 return true;
25407               case 1: //src_1
25408                 return true;
25409               default:
25410                 fatal("op idx %i out of bounds\n", opIdx);
25411                 return false;
25412             }
25413         } // isSrcOperand
25414
25415         bool
25416         isDstOperand(int opIdx) override
25417         {
25418             switch (opIdx) {
25419               case 0: //src_0
25420                 return false;
25421               case 1: //src_1
25422                 return false;
25423               default:
25424                 fatal("op idx %i out of bounds\n", opIdx);
25425                 return false;
25426             }
25427         } // isDstOperand
25428
25429         void execute(GPUDynInstPtr) override;
25430     }; // Inst_VOPC__V_CMPX_O_F64
25431
25432     class Inst_VOPC__V_CMPX_U_F64 : public Inst_VOPC
25433     {
25434       public:
25435         Inst_VOPC__V_CMPX_U_F64(InFmt_VOPC*);
25436         ~Inst_VOPC__V_CMPX_U_F64();
25437
25438         int
25439         getNumOperands() override
25440         {
25441             return numDstRegOperands() + numSrcRegOperands();
25442         } // getNumOperands
25443
25444         int numDstRegOperands() override { return 1; }
25445         int numSrcRegOperands() override { return 2; }
25446
25447         int
25448         getOperandSize(int opIdx) override
25449         {
25450             switch (opIdx) {
25451               case 0: //src_0
25452                 return 8;
25453               case 1: //src_1
25454                 return 8;
25455               case 2: //vcc
25456                 return 8;
25457               default:
25458                 fatal("op idx %i out of bounds\n", opIdx);
25459                 return -1;
25460             }
25461         } // getOperandSize
25462
25463         bool
25464         isSrcOperand(int opIdx) override
25465         {
25466             switch (opIdx) {
25467               case 0: //src_0
25468                 return true;
25469               case 1: //src_1
25470                 return true;
25471               default:
25472                 fatal("op idx %i out of bounds\n", opIdx);
25473                 return false;
25474             }
25475         } // isSrcOperand
25476
25477         bool
25478         isDstOperand(int opIdx) override
25479         {
25480             switch (opIdx) {
25481               case 0: //src_0
25482                 return false;
25483               case 1: //src_1
25484                 return false;
25485               default:
25486                 fatal("op idx %i out of bounds\n", opIdx);
25487                 return false;
25488             }
25489         } // isDstOperand
25490
25491         void execute(GPUDynInstPtr) override;
25492     }; // Inst_VOPC__V_CMPX_U_F64
25493
25494     class Inst_VOPC__V_CMPX_NGE_F64 : public Inst_VOPC
25495     {
25496       public:
25497         Inst_VOPC__V_CMPX_NGE_F64(InFmt_VOPC*);
25498         ~Inst_VOPC__V_CMPX_NGE_F64();
25499
25500         int
25501         getNumOperands() override
25502         {
25503             return numDstRegOperands() + numSrcRegOperands();
25504         } // getNumOperands
25505
25506         int numDstRegOperands() override { return 1; }
25507         int numSrcRegOperands() override { return 2; }
25508
25509         int
25510         getOperandSize(int opIdx) override
25511         {
25512             switch (opIdx) {
25513               case 0: //src_0
25514                 return 8;
25515               case 1: //src_1
25516                 return 8;
25517               case 2: //vcc
25518                 return 8;
25519               default:
25520                 fatal("op idx %i out of bounds\n", opIdx);
25521                 return -1;
25522             }
25523         } // getOperandSize
25524
25525         bool
25526         isSrcOperand(int opIdx) override
25527         {
25528             switch (opIdx) {
25529               case 0: //src_0
25530                 return true;
25531               case 1: //src_1
25532                 return true;
25533               default:
25534                 fatal("op idx %i out of bounds\n", opIdx);
25535                 return false;
25536             }
25537         } // isSrcOperand
25538
25539         bool
25540         isDstOperand(int opIdx) override
25541         {
25542             switch (opIdx) {
25543               case 0: //src_0
25544                 return false;
25545               case 1: //src_1
25546                 return false;
25547               default:
25548                 fatal("op idx %i out of bounds\n", opIdx);
25549                 return false;
25550             }
25551         } // isDstOperand
25552
25553         void execute(GPUDynInstPtr) override;
25554     }; // Inst_VOPC__V_CMPX_NGE_F64
25555
25556     class Inst_VOPC__V_CMPX_NLG_F64 : public Inst_VOPC
25557     {
25558       public:
25559         Inst_VOPC__V_CMPX_NLG_F64(InFmt_VOPC*);
25560         ~Inst_VOPC__V_CMPX_NLG_F64();
25561
25562         int
25563         getNumOperands() override
25564         {
25565             return numDstRegOperands() + numSrcRegOperands();
25566         } // getNumOperands
25567
25568         int numDstRegOperands() override { return 1; }
25569         int numSrcRegOperands() override { return 2; }
25570
25571         int
25572         getOperandSize(int opIdx) override
25573         {
25574             switch (opIdx) {
25575               case 0: //src_0
25576                 return 8;
25577               case 1: //src_1
25578                 return 8;
25579               case 2: //vcc
25580                 return 8;
25581               default:
25582                 fatal("op idx %i out of bounds\n", opIdx);
25583                 return -1;
25584             }
25585         } // getOperandSize
25586
25587         bool
25588         isSrcOperand(int opIdx) override
25589         {
25590             switch (opIdx) {
25591               case 0: //src_0
25592                 return true;
25593               case 1: //src_1
25594                 return true;
25595               default:
25596                 fatal("op idx %i out of bounds\n", opIdx);
25597                 return false;
25598             }
25599         } // isSrcOperand
25600
25601         bool
25602         isDstOperand(int opIdx) override
25603         {
25604             switch (opIdx) {
25605               case 0: //src_0
25606                 return false;
25607               case 1: //src_1
25608                 return false;
25609               default:
25610                 fatal("op idx %i out of bounds\n", opIdx);
25611                 return false;
25612             }
25613         } // isDstOperand
25614
25615         void execute(GPUDynInstPtr) override;
25616     }; // Inst_VOPC__V_CMPX_NLG_F64
25617
25618     class Inst_VOPC__V_CMPX_NGT_F64 : public Inst_VOPC
25619     {
25620       public:
25621         Inst_VOPC__V_CMPX_NGT_F64(InFmt_VOPC*);
25622         ~Inst_VOPC__V_CMPX_NGT_F64();
25623
25624         int
25625         getNumOperands() override
25626         {
25627             return numDstRegOperands() + numSrcRegOperands();
25628         } // getNumOperands
25629
25630         int numDstRegOperands() override { return 1; }
25631         int numSrcRegOperands() override { return 2; }
25632
25633         int
25634         getOperandSize(int opIdx) override
25635         {
25636             switch (opIdx) {
25637               case 0: //src_0
25638                 return 8;
25639               case 1: //src_1
25640                 return 8;
25641               case 2: //vcc
25642                 return 8;
25643               default:
25644                 fatal("op idx %i out of bounds\n", opIdx);
25645                 return -1;
25646             }
25647         } // getOperandSize
25648
25649         bool
25650         isSrcOperand(int opIdx) override
25651         {
25652             switch (opIdx) {
25653               case 0: //src_0
25654                 return true;
25655               case 1: //src_1
25656                 return true;
25657               default:
25658                 fatal("op idx %i out of bounds\n", opIdx);
25659                 return false;
25660             }
25661         } // isSrcOperand
25662
25663         bool
25664         isDstOperand(int opIdx) override
25665         {
25666             switch (opIdx) {
25667               case 0: //src_0
25668                 return false;
25669               case 1: //src_1
25670                 return false;
25671               default:
25672                 fatal("op idx %i out of bounds\n", opIdx);
25673                 return false;
25674             }
25675         } // isDstOperand
25676
25677         void execute(GPUDynInstPtr) override;
25678     }; // Inst_VOPC__V_CMPX_NGT_F64
25679
25680     class Inst_VOPC__V_CMPX_NLE_F64 : public Inst_VOPC
25681     {
25682       public:
25683         Inst_VOPC__V_CMPX_NLE_F64(InFmt_VOPC*);
25684         ~Inst_VOPC__V_CMPX_NLE_F64();
25685
25686         int
25687         getNumOperands() override
25688         {
25689             return numDstRegOperands() + numSrcRegOperands();
25690         } // getNumOperands
25691
25692         int numDstRegOperands() override { return 1; }
25693         int numSrcRegOperands() override { return 2; }
25694
25695         int
25696         getOperandSize(int opIdx) override
25697         {
25698             switch (opIdx) {
25699               case 0: //src_0
25700                 return 8;
25701               case 1: //src_1
25702                 return 8;
25703               case 2: //vcc
25704                 return 8;
25705               default:
25706                 fatal("op idx %i out of bounds\n", opIdx);
25707                 return -1;
25708             }
25709         } // getOperandSize
25710
25711         bool
25712         isSrcOperand(int opIdx) override
25713         {
25714             switch (opIdx) {
25715               case 0: //src_0
25716                 return true;
25717               case 1: //src_1
25718                 return true;
25719               default:
25720                 fatal("op idx %i out of bounds\n", opIdx);
25721                 return false;
25722             }
25723         } // isSrcOperand
25724
25725         bool
25726         isDstOperand(int opIdx) override
25727         {
25728             switch (opIdx) {
25729               case 0: //src_0
25730                 return false;
25731               case 1: //src_1
25732                 return false;
25733               default:
25734                 fatal("op idx %i out of bounds\n", opIdx);
25735                 return false;
25736             }
25737         } // isDstOperand
25738
25739         void execute(GPUDynInstPtr) override;
25740     }; // Inst_VOPC__V_CMPX_NLE_F64
25741
25742     class Inst_VOPC__V_CMPX_NEQ_F64 : public Inst_VOPC
25743     {
25744       public:
25745         Inst_VOPC__V_CMPX_NEQ_F64(InFmt_VOPC*);
25746         ~Inst_VOPC__V_CMPX_NEQ_F64();
25747
25748         int
25749         getNumOperands() override
25750         {
25751             return numDstRegOperands() + numSrcRegOperands();
25752         } // getNumOperands
25753
25754         int numDstRegOperands() override { return 1; }
25755         int numSrcRegOperands() override { return 2; }
25756
25757         int
25758         getOperandSize(int opIdx) override
25759         {
25760             switch (opIdx) {
25761               case 0: //src_0
25762                 return 8;
25763               case 1: //src_1
25764                 return 8;
25765               case 2: //vcc
25766                 return 8;
25767               default:
25768                 fatal("op idx %i out of bounds\n", opIdx);
25769                 return -1;
25770             }
25771         } // getOperandSize
25772
25773         bool
25774         isSrcOperand(int opIdx) override
25775         {
25776             switch (opIdx) {
25777               case 0: //src_0
25778                 return true;
25779               case 1: //src_1
25780                 return true;
25781               default:
25782                 fatal("op idx %i out of bounds\n", opIdx);
25783                 return false;
25784             }
25785         } // isSrcOperand
25786
25787         bool
25788         isDstOperand(int opIdx) override
25789         {
25790             switch (opIdx) {
25791               case 0: //src_0
25792                 return false;
25793               case 1: //src_1
25794                 return false;
25795               default:
25796                 fatal("op idx %i out of bounds\n", opIdx);
25797                 return false;
25798             }
25799         } // isDstOperand
25800
25801         void execute(GPUDynInstPtr) override;
25802     }; // Inst_VOPC__V_CMPX_NEQ_F64
25803
25804     class Inst_VOPC__V_CMPX_NLT_F64 : public Inst_VOPC
25805     {
25806       public:
25807         Inst_VOPC__V_CMPX_NLT_F64(InFmt_VOPC*);
25808         ~Inst_VOPC__V_CMPX_NLT_F64();
25809
25810         int
25811         getNumOperands() override
25812         {
25813             return numDstRegOperands() + numSrcRegOperands();
25814         } // getNumOperands
25815
25816         int numDstRegOperands() override { return 1; }
25817         int numSrcRegOperands() override { return 2; }
25818
25819         int
25820         getOperandSize(int opIdx) override
25821         {
25822             switch (opIdx) {
25823               case 0: //src_0
25824                 return 8;
25825               case 1: //src_1
25826                 return 8;
25827               case 2: //vcc
25828                 return 8;
25829               default:
25830                 fatal("op idx %i out of bounds\n", opIdx);
25831                 return -1;
25832             }
25833         } // getOperandSize
25834
25835         bool
25836         isSrcOperand(int opIdx) override
25837         {
25838             switch (opIdx) {
25839               case 0: //src_0
25840                 return true;
25841               case 1: //src_1
25842                 return true;
25843               default:
25844                 fatal("op idx %i out of bounds\n", opIdx);
25845                 return false;
25846             }
25847         } // isSrcOperand
25848
25849         bool
25850         isDstOperand(int opIdx) override
25851         {
25852             switch (opIdx) {
25853               case 0: //src_0
25854                 return false;
25855               case 1: //src_1
25856                 return false;
25857               default:
25858                 fatal("op idx %i out of bounds\n", opIdx);
25859                 return false;
25860             }
25861         } // isDstOperand
25862
25863         void execute(GPUDynInstPtr) override;
25864     }; // Inst_VOPC__V_CMPX_NLT_F64
25865
25866     class Inst_VOPC__V_CMPX_TRU_F64 : public Inst_VOPC
25867     {
25868       public:
25869         Inst_VOPC__V_CMPX_TRU_F64(InFmt_VOPC*);
25870         ~Inst_VOPC__V_CMPX_TRU_F64();
25871
25872         int
25873         getNumOperands() override
25874         {
25875             return numDstRegOperands() + numSrcRegOperands();
25876         } // getNumOperands
25877
25878         int numDstRegOperands() override { return 1; }
25879         int numSrcRegOperands() override { return 2; }
25880
25881         int
25882         getOperandSize(int opIdx) override
25883         {
25884             switch (opIdx) {
25885               case 0: //src_0
25886                 return 8;
25887               case 1: //src_1
25888                 return 8;
25889               case 2: //vcc
25890                 return 8;
25891               default:
25892                 fatal("op idx %i out of bounds\n", opIdx);
25893                 return -1;
25894             }
25895         } // getOperandSize
25896
25897         bool
25898         isSrcOperand(int opIdx) override
25899         {
25900             switch (opIdx) {
25901               case 0: //src_0
25902                 return true;
25903               case 1: //src_1
25904                 return true;
25905               default:
25906                 fatal("op idx %i out of bounds\n", opIdx);
25907                 return false;
25908             }
25909         } // isSrcOperand
25910
25911         bool
25912         isDstOperand(int opIdx) override
25913         {
25914             switch (opIdx) {
25915               case 0: //src_0
25916                 return false;
25917               case 1: //src_1
25918                 return false;
25919               default:
25920                 fatal("op idx %i out of bounds\n", opIdx);
25921                 return false;
25922             }
25923         } // isDstOperand
25924
25925         void execute(GPUDynInstPtr) override;
25926     }; // Inst_VOPC__V_CMPX_TRU_F64
25927
25928     class Inst_VOPC__V_CMP_F_I16 : public Inst_VOPC
25929     {
25930       public:
25931         Inst_VOPC__V_CMP_F_I16(InFmt_VOPC*);
25932         ~Inst_VOPC__V_CMP_F_I16();
25933
25934         int
25935         getNumOperands() override
25936         {
25937             return numDstRegOperands() + numSrcRegOperands();
25938         } // getNumOperands
25939
25940         int numDstRegOperands() override { return 1; }
25941         int numSrcRegOperands() override { return 2; }
25942
25943         int
25944         getOperandSize(int opIdx) override
25945         {
25946             switch (opIdx) {
25947               case 0: //src_0
25948                 return 2;
25949               case 1: //src_1
25950                 return 2;
25951               case 2: //vcc
25952                 return 8;
25953               default:
25954                 fatal("op idx %i out of bounds\n", opIdx);
25955                 return -1;
25956             }
25957         } // getOperandSize
25958
25959         bool
25960         isSrcOperand(int opIdx) override
25961         {
25962             switch (opIdx) {
25963               case 0: //src_0
25964                 return true;
25965               case 1: //src_1
25966                 return true;
25967               case 2: //vcc
25968                 return false;
25969               default:
25970                 fatal("op idx %i out of bounds\n", opIdx);
25971                 return false;
25972             }
25973         } // isSrcOperand
25974
25975         bool
25976         isDstOperand(int opIdx) override
25977         {
25978             switch (opIdx) {
25979               case 0: //src_0
25980                 return false;
25981               case 1: //src_1
25982                 return false;
25983               case 2: //vcc
25984                 return true;
25985               default:
25986                 fatal("op idx %i out of bounds\n", opIdx);
25987                 return false;
25988             }
25989         } // isDstOperand
25990
25991         void execute(GPUDynInstPtr) override;
25992     }; // Inst_VOPC__V_CMP_F_I16
25993
25994     class Inst_VOPC__V_CMP_LT_I16 : public Inst_VOPC
25995     {
25996       public:
25997         Inst_VOPC__V_CMP_LT_I16(InFmt_VOPC*);
25998         ~Inst_VOPC__V_CMP_LT_I16();
25999
26000         int
26001         getNumOperands() override
26002         {
26003             return numDstRegOperands() + numSrcRegOperands();
26004         } // getNumOperands
26005
26006         int numDstRegOperands() override { return 1; }
26007         int numSrcRegOperands() override { return 2; }
26008
26009         int
26010         getOperandSize(int opIdx) override
26011         {
26012             switch (opIdx) {
26013               case 0: //src_0
26014                 return 2;
26015               case 1: //src_1
26016                 return 2;
26017               case 2: //vcc
26018                 return 8;
26019               default:
26020                 fatal("op idx %i out of bounds\n", opIdx);
26021                 return -1;
26022             }
26023         } // getOperandSize
26024
26025         bool
26026         isSrcOperand(int opIdx) override
26027         {
26028             switch (opIdx) {
26029               case 0: //src_0
26030                 return true;
26031               case 1: //src_1
26032                 return true;
26033               case 2: //vcc
26034                 return false;
26035               default:
26036                 fatal("op idx %i out of bounds\n", opIdx);
26037                 return false;
26038             }
26039         } // isSrcOperand
26040
26041         bool
26042         isDstOperand(int opIdx) override
26043         {
26044             switch (opIdx) {
26045               case 0: //src_0
26046                 return false;
26047               case 1: //src_1
26048                 return false;
26049               case 2: //vcc
26050                 return true;
26051               default:
26052                 fatal("op idx %i out of bounds\n", opIdx);
26053                 return false;
26054             }
26055         } // isDstOperand
26056
26057         void execute(GPUDynInstPtr) override;
26058     }; // Inst_VOPC__V_CMP_LT_I16
26059
26060     class Inst_VOPC__V_CMP_EQ_I16 : public Inst_VOPC
26061     {
26062       public:
26063         Inst_VOPC__V_CMP_EQ_I16(InFmt_VOPC*);
26064         ~Inst_VOPC__V_CMP_EQ_I16();
26065
26066         int
26067         getNumOperands() override
26068         {
26069             return numDstRegOperands() + numSrcRegOperands();
26070         } // getNumOperands
26071
26072         int numDstRegOperands() override { return 1; }
26073         int numSrcRegOperands() override { return 2; }
26074
26075         int
26076         getOperandSize(int opIdx) override
26077         {
26078             switch (opIdx) {
26079               case 0: //src_0
26080                 return 2;
26081               case 1: //src_1
26082                 return 2;
26083               case 2: //vcc
26084                 return 8;
26085               default:
26086                 fatal("op idx %i out of bounds\n", opIdx);
26087                 return -1;
26088             }
26089         } // getOperandSize
26090
26091         bool
26092         isSrcOperand(int opIdx) override
26093         {
26094             switch (opIdx) {
26095               case 0: //src_0
26096                 return true;
26097               case 1: //src_1
26098                 return true;
26099               case 2: //vcc
26100                 return false;
26101               default:
26102                 fatal("op idx %i out of bounds\n", opIdx);
26103                 return false;
26104             }
26105         } // isSrcOperand
26106
26107         bool
26108         isDstOperand(int opIdx) override
26109         {
26110             switch (opIdx) {
26111               case 0: //src_0
26112                 return false;
26113               case 1: //src_1
26114                 return false;
26115               case 2: //vcc
26116                 return true;
26117               default:
26118                 fatal("op idx %i out of bounds\n", opIdx);
26119                 return false;
26120             }
26121         } // isDstOperand
26122
26123         void execute(GPUDynInstPtr) override;
26124     }; // Inst_VOPC__V_CMP_EQ_I16
26125
26126     class Inst_VOPC__V_CMP_LE_I16 : public Inst_VOPC
26127     {
26128       public:
26129         Inst_VOPC__V_CMP_LE_I16(InFmt_VOPC*);
26130         ~Inst_VOPC__V_CMP_LE_I16();
26131
26132         int
26133         getNumOperands() override
26134         {
26135             return numDstRegOperands() + numSrcRegOperands();
26136         } // getNumOperands
26137
26138         int numDstRegOperands() override { return 1; }
26139         int numSrcRegOperands() override { return 2; }
26140
26141         int
26142         getOperandSize(int opIdx) override
26143         {
26144             switch (opIdx) {
26145               case 0: //src_0
26146                 return 2;
26147               case 1: //src_1
26148                 return 2;
26149               case 2: //vcc
26150                 return 8;
26151               default:
26152                 fatal("op idx %i out of bounds\n", opIdx);
26153                 return -1;
26154             }
26155         } // getOperandSize
26156
26157         bool
26158         isSrcOperand(int opIdx) override
26159         {
26160             switch (opIdx) {
26161               case 0: //src_0
26162                 return true;
26163               case 1: //src_1
26164                 return true;
26165               case 2: //vcc
26166                 return false;
26167               default:
26168                 fatal("op idx %i out of bounds\n", opIdx);
26169                 return false;
26170             }
26171         } // isSrcOperand
26172
26173         bool
26174         isDstOperand(int opIdx) override
26175         {
26176             switch (opIdx) {
26177               case 0: //src_0
26178                 return false;
26179               case 1: //src_1
26180                 return false;
26181               case 2: //vcc
26182                 return true;
26183               default:
26184                 fatal("op idx %i out of bounds\n", opIdx);
26185                 return false;
26186             }
26187         } // isDstOperand
26188
26189         void execute(GPUDynInstPtr) override;
26190     }; // Inst_VOPC__V_CMP_LE_I16
26191
26192     class Inst_VOPC__V_CMP_GT_I16 : public Inst_VOPC
26193     {
26194       public:
26195         Inst_VOPC__V_CMP_GT_I16(InFmt_VOPC*);
26196         ~Inst_VOPC__V_CMP_GT_I16();
26197
26198         int
26199         getNumOperands() override
26200         {
26201             return numDstRegOperands() + numSrcRegOperands();
26202         } // getNumOperands
26203
26204         int numDstRegOperands() override { return 1; }
26205         int numSrcRegOperands() override { return 2; }
26206
26207         int
26208         getOperandSize(int opIdx) override
26209         {
26210             switch (opIdx) {
26211               case 0: //src_0
26212                 return 2;
26213               case 1: //src_1
26214                 return 2;
26215               case 2: //vcc
26216                 return 8;
26217               default:
26218                 fatal("op idx %i out of bounds\n", opIdx);
26219                 return -1;
26220             }
26221         } // getOperandSize
26222
26223         bool
26224         isSrcOperand(int opIdx) override
26225         {
26226             switch (opIdx) {
26227               case 0: //src_0
26228                 return true;
26229               case 1: //src_1
26230                 return true;
26231               case 2: //vcc
26232                 return false;
26233               default:
26234                 fatal("op idx %i out of bounds\n", opIdx);
26235                 return false;
26236             }
26237         } // isSrcOperand
26238
26239         bool
26240         isDstOperand(int opIdx) override
26241         {
26242             switch (opIdx) {
26243               case 0: //src_0
26244                 return false;
26245               case 1: //src_1
26246                 return false;
26247               case 2: //vcc
26248                 return true;
26249               default:
26250                 fatal("op idx %i out of bounds\n", opIdx);
26251                 return false;
26252             }
26253         } // isDstOperand
26254
26255         void execute(GPUDynInstPtr) override;
26256     }; // Inst_VOPC__V_CMP_GT_I16
26257
26258     class Inst_VOPC__V_CMP_NE_I16 : public Inst_VOPC
26259     {
26260       public:
26261         Inst_VOPC__V_CMP_NE_I16(InFmt_VOPC*);
26262         ~Inst_VOPC__V_CMP_NE_I16();
26263
26264         int
26265         getNumOperands() override
26266         {
26267             return numDstRegOperands() + numSrcRegOperands();
26268         } // getNumOperands
26269
26270         int numDstRegOperands() override { return 1; }
26271         int numSrcRegOperands() override { return 2; }
26272
26273         int
26274         getOperandSize(int opIdx) override
26275         {
26276             switch (opIdx) {
26277               case 0: //src_0
26278                 return 2;
26279               case 1: //src_1
26280                 return 2;
26281               case 2: //vcc
26282                 return 8;
26283               default:
26284                 fatal("op idx %i out of bounds\n", opIdx);
26285                 return -1;
26286             }
26287         } // getOperandSize
26288
26289         bool
26290         isSrcOperand(int opIdx) override
26291         {
26292             switch (opIdx) {
26293               case 0: //src_0
26294                 return true;
26295               case 1: //src_1
26296                 return true;
26297               case 2: //vcc
26298                 return false;
26299               default:
26300                 fatal("op idx %i out of bounds\n", opIdx);
26301                 return false;
26302             }
26303         } // isSrcOperand
26304
26305         bool
26306         isDstOperand(int opIdx) override
26307         {
26308             switch (opIdx) {
26309               case 0: //src_0
26310                 return false;
26311               case 1: //src_1
26312                 return false;
26313               case 2: //vcc
26314                 return true;
26315               default:
26316                 fatal("op idx %i out of bounds\n", opIdx);
26317                 return false;
26318             }
26319         } // isDstOperand
26320
26321         void execute(GPUDynInstPtr) override;
26322     }; // Inst_VOPC__V_CMP_NE_I16
26323
26324     class Inst_VOPC__V_CMP_GE_I16 : public Inst_VOPC
26325     {
26326       public:
26327         Inst_VOPC__V_CMP_GE_I16(InFmt_VOPC*);
26328         ~Inst_VOPC__V_CMP_GE_I16();
26329
26330         int
26331         getNumOperands() override
26332         {
26333             return numDstRegOperands() + numSrcRegOperands();
26334         } // getNumOperands
26335
26336         int numDstRegOperands() override { return 1; }
26337         int numSrcRegOperands() override { return 2; }
26338
26339         int
26340         getOperandSize(int opIdx) override
26341         {
26342             switch (opIdx) {
26343               case 0: //src_0
26344                 return 2;
26345               case 1: //src_1
26346                 return 2;
26347               case 2: //vcc
26348                 return 8;
26349               default:
26350                 fatal("op idx %i out of bounds\n", opIdx);
26351                 return -1;
26352             }
26353         } // getOperandSize
26354
26355         bool
26356         isSrcOperand(int opIdx) override
26357         {
26358             switch (opIdx) {
26359               case 0: //src_0
26360                 return true;
26361               case 1: //src_1
26362                 return true;
26363               case 2: //vcc
26364                 return false;
26365               default:
26366                 fatal("op idx %i out of bounds\n", opIdx);
26367                 return false;
26368             }
26369         } // isSrcOperand
26370
26371         bool
26372         isDstOperand(int opIdx) override
26373         {
26374             switch (opIdx) {
26375               case 0: //src_0
26376                 return false;
26377               case 1: //src_1
26378                 return false;
26379               case 2: //vcc
26380                 return true;
26381               default:
26382                 fatal("op idx %i out of bounds\n", opIdx);
26383                 return false;
26384             }
26385         } // isDstOperand
26386
26387         void execute(GPUDynInstPtr) override;
26388     }; // Inst_VOPC__V_CMP_GE_I16
26389
26390     class Inst_VOPC__V_CMP_T_I16 : public Inst_VOPC
26391     {
26392       public:
26393         Inst_VOPC__V_CMP_T_I16(InFmt_VOPC*);
26394         ~Inst_VOPC__V_CMP_T_I16();
26395
26396         int
26397         getNumOperands() override
26398         {
26399             return numDstRegOperands() + numSrcRegOperands();
26400         } // getNumOperands
26401
26402         int numDstRegOperands() override { return 1; }
26403         int numSrcRegOperands() override { return 2; }
26404
26405         int
26406         getOperandSize(int opIdx) override
26407         {
26408             switch (opIdx) {
26409               case 0: //src_0
26410                 return 2;
26411               case 1: //src_1
26412                 return 2;
26413               case 2: //vcc
26414                 return 8;
26415               default:
26416                 fatal("op idx %i out of bounds\n", opIdx);
26417                 return -1;
26418             }
26419         } // getOperandSize
26420
26421         bool
26422         isSrcOperand(int opIdx) override
26423         {
26424             switch (opIdx) {
26425               case 0: //src_0
26426                 return true;
26427               case 1: //src_1
26428                 return true;
26429               case 2: //vcc
26430                 return false;
26431               default:
26432                 fatal("op idx %i out of bounds\n", opIdx);
26433                 return false;
26434             }
26435         } // isSrcOperand
26436
26437         bool
26438         isDstOperand(int opIdx) override
26439         {
26440             switch (opIdx) {
26441               case 0: //src_0
26442                 return false;
26443               case 1: //src_1
26444                 return false;
26445               case 2: //vcc
26446                 return true;
26447               default:
26448                 fatal("op idx %i out of bounds\n", opIdx);
26449                 return false;
26450             }
26451         } // isDstOperand
26452
26453         void execute(GPUDynInstPtr) override;
26454     }; // Inst_VOPC__V_CMP_T_I16
26455
26456     class Inst_VOPC__V_CMP_F_U16 : public Inst_VOPC
26457     {
26458       public:
26459         Inst_VOPC__V_CMP_F_U16(InFmt_VOPC*);
26460         ~Inst_VOPC__V_CMP_F_U16();
26461
26462         int
26463         getNumOperands() override
26464         {
26465             return numDstRegOperands() + numSrcRegOperands();
26466         } // getNumOperands
26467
26468         int numDstRegOperands() override { return 1; }
26469         int numSrcRegOperands() override { return 2; }
26470
26471         int
26472         getOperandSize(int opIdx) override
26473         {
26474             switch (opIdx) {
26475               case 0: //src_0
26476                 return 2;
26477               case 1: //src_1
26478                 return 2;
26479               case 2: //vcc
26480                 return 8;
26481               default:
26482                 fatal("op idx %i out of bounds\n", opIdx);
26483                 return -1;
26484             }
26485         } // getOperandSize
26486
26487         bool
26488         isSrcOperand(int opIdx) override
26489         {
26490             switch (opIdx) {
26491               case 0: //src_0
26492                 return true;
26493               case 1: //src_1
26494                 return true;
26495               case 2: //vcc
26496                 return false;
26497               default:
26498                 fatal("op idx %i out of bounds\n", opIdx);
26499                 return false;
26500             }
26501         } // isSrcOperand
26502
26503         bool
26504         isDstOperand(int opIdx) override
26505         {
26506             switch (opIdx) {
26507               case 0: //src_0
26508                 return false;
26509               case 1: //src_1
26510                 return false;
26511               case 2: //vcc
26512                 return true;
26513               default:
26514                 fatal("op idx %i out of bounds\n", opIdx);
26515                 return false;
26516             }
26517         } // isDstOperand
26518
26519         void execute(GPUDynInstPtr) override;
26520     }; // Inst_VOPC__V_CMP_F_U16
26521
26522     class Inst_VOPC__V_CMP_LT_U16 : public Inst_VOPC
26523     {
26524       public:
26525         Inst_VOPC__V_CMP_LT_U16(InFmt_VOPC*);
26526         ~Inst_VOPC__V_CMP_LT_U16();
26527
26528         int
26529         getNumOperands() override
26530         {
26531             return numDstRegOperands() + numSrcRegOperands();
26532         } // getNumOperands
26533
26534         int numDstRegOperands() override { return 1; }
26535         int numSrcRegOperands() override { return 2; }
26536
26537         int
26538         getOperandSize(int opIdx) override
26539         {
26540             switch (opIdx) {
26541               case 0: //src_0
26542                 return 2;
26543               case 1: //src_1
26544                 return 2;
26545               case 2: //vcc
26546                 return 8;
26547               default:
26548                 fatal("op idx %i out of bounds\n", opIdx);
26549                 return -1;
26550             }
26551         } // getOperandSize
26552
26553         bool
26554         isSrcOperand(int opIdx) override
26555         {
26556             switch (opIdx) {
26557               case 0: //src_0
26558                 return true;
26559               case 1: //src_1
26560                 return true;
26561               case 2: //vcc
26562                 return false;
26563               default:
26564                 fatal("op idx %i out of bounds\n", opIdx);
26565                 return false;
26566             }
26567         } // isSrcOperand
26568
26569         bool
26570         isDstOperand(int opIdx) override
26571         {
26572             switch (opIdx) {
26573               case 0: //src_0
26574                 return false;
26575               case 1: //src_1
26576                 return false;
26577               case 2: //vcc
26578                 return true;
26579               default:
26580                 fatal("op idx %i out of bounds\n", opIdx);
26581                 return false;
26582             }
26583         } // isDstOperand
26584
26585         void execute(GPUDynInstPtr) override;
26586     }; // Inst_VOPC__V_CMP_LT_U16
26587
26588     class Inst_VOPC__V_CMP_EQ_U16 : public Inst_VOPC
26589     {
26590       public:
26591         Inst_VOPC__V_CMP_EQ_U16(InFmt_VOPC*);
26592         ~Inst_VOPC__V_CMP_EQ_U16();
26593
26594         int
26595         getNumOperands() override
26596         {
26597             return numDstRegOperands() + numSrcRegOperands();
26598         } // getNumOperands
26599
26600         int numDstRegOperands() override { return 1; }
26601         int numSrcRegOperands() override { return 2; }
26602
26603         int
26604         getOperandSize(int opIdx) override
26605         {
26606             switch (opIdx) {
26607               case 0: //src_0
26608                 return 2;
26609               case 1: //src_1
26610                 return 2;
26611               case 2: //vcc
26612                 return 8;
26613               default:
26614                 fatal("op idx %i out of bounds\n", opIdx);
26615                 return -1;
26616             }
26617         } // getOperandSize
26618
26619         bool
26620         isSrcOperand(int opIdx) override
26621         {
26622             switch (opIdx) {
26623               case 0: //src_0
26624                 return true;
26625               case 1: //src_1
26626                 return true;
26627               case 2: //vcc
26628                 return false;
26629               default:
26630                 fatal("op idx %i out of bounds\n", opIdx);
26631                 return false;
26632             }
26633         } // isSrcOperand
26634
26635         bool
26636         isDstOperand(int opIdx) override
26637         {
26638             switch (opIdx) {
26639               case 0: //src_0
26640                 return false;
26641               case 1: //src_1
26642                 return false;
26643               case 2: //vcc
26644                 return true;
26645               default:
26646                 fatal("op idx %i out of bounds\n", opIdx);
26647                 return false;
26648             }
26649         } // isDstOperand
26650
26651         void execute(GPUDynInstPtr) override;
26652     }; // Inst_VOPC__V_CMP_EQ_U16
26653
26654     class Inst_VOPC__V_CMP_LE_U16 : public Inst_VOPC
26655     {
26656       public:
26657         Inst_VOPC__V_CMP_LE_U16(InFmt_VOPC*);
26658         ~Inst_VOPC__V_CMP_LE_U16();
26659
26660         int
26661         getNumOperands() override
26662         {
26663             return numDstRegOperands() + numSrcRegOperands();
26664         } // getNumOperands
26665
26666         int numDstRegOperands() override { return 1; }
26667         int numSrcRegOperands() override { return 2; }
26668
26669         int
26670         getOperandSize(int opIdx) override
26671         {
26672             switch (opIdx) {
26673               case 0: //src_0
26674                 return 2;
26675               case 1: //src_1
26676                 return 2;
26677               case 2: //vcc
26678                 return 8;
26679               default:
26680                 fatal("op idx %i out of bounds\n", opIdx);
26681                 return -1;
26682             }
26683         } // getOperandSize
26684
26685         bool
26686         isSrcOperand(int opIdx) override
26687         {
26688             switch (opIdx) {
26689               case 0: //src_0
26690                 return true;
26691               case 1: //src_1
26692                 return true;
26693               case 2: //vcc
26694                 return false;
26695               default:
26696                 fatal("op idx %i out of bounds\n", opIdx);
26697                 return false;
26698             }
26699         } // isSrcOperand
26700
26701         bool
26702         isDstOperand(int opIdx) override
26703         {
26704             switch (opIdx) {
26705               case 0: //src_0
26706                 return false;
26707               case 1: //src_1
26708                 return false;
26709               case 2: //vcc
26710                 return true;
26711               default:
26712                 fatal("op idx %i out of bounds\n", opIdx);
26713                 return false;
26714             }
26715         } // isDstOperand
26716
26717         void execute(GPUDynInstPtr) override;
26718     }; // Inst_VOPC__V_CMP_LE_U16
26719
26720     class Inst_VOPC__V_CMP_GT_U16 : public Inst_VOPC
26721     {
26722       public:
26723         Inst_VOPC__V_CMP_GT_U16(InFmt_VOPC*);
26724         ~Inst_VOPC__V_CMP_GT_U16();
26725
26726         int
26727         getNumOperands() override
26728         {
26729             return numDstRegOperands() + numSrcRegOperands();
26730         } // getNumOperands
26731
26732         int numDstRegOperands() override { return 1; }
26733         int numSrcRegOperands() override { return 2; }
26734
26735         int
26736         getOperandSize(int opIdx) override
26737         {
26738             switch (opIdx) {
26739               case 0: //src_0
26740                 return 2;
26741               case 1: //src_1
26742                 return 2;
26743               case 2: //vcc
26744                 return 8;
26745               default:
26746                 fatal("op idx %i out of bounds\n", opIdx);
26747                 return -1;
26748             }
26749         } // getOperandSize
26750
26751         bool
26752         isSrcOperand(int opIdx) override
26753         {
26754             switch (opIdx) {
26755               case 0: //src_0
26756                 return true;
26757               case 1: //src_1
26758                 return true;
26759               case 2: //vcc
26760                 return false;
26761               default:
26762                 fatal("op idx %i out of bounds\n", opIdx);
26763                 return false;
26764             }
26765         } // isSrcOperand
26766
26767         bool
26768         isDstOperand(int opIdx) override
26769         {
26770             switch (opIdx) {
26771               case 0: //src_0
26772                 return false;
26773               case 1: //src_1
26774                 return false;
26775               case 2: //vcc
26776                 return true;
26777               default:
26778                 fatal("op idx %i out of bounds\n", opIdx);
26779                 return false;
26780             }
26781         } // isDstOperand
26782
26783         void execute(GPUDynInstPtr) override;
26784     }; // Inst_VOPC__V_CMP_GT_U16
26785
26786     class Inst_VOPC__V_CMP_NE_U16 : public Inst_VOPC
26787     {
26788       public:
26789         Inst_VOPC__V_CMP_NE_U16(InFmt_VOPC*);
26790         ~Inst_VOPC__V_CMP_NE_U16();
26791
26792         int
26793         getNumOperands() override
26794         {
26795             return numDstRegOperands() + numSrcRegOperands();
26796         } // getNumOperands
26797
26798         int numDstRegOperands() override { return 1; }
26799         int numSrcRegOperands() override { return 2; }
26800
26801         int
26802         getOperandSize(int opIdx) override
26803         {
26804             switch (opIdx) {
26805               case 0: //src_0
26806                 return 2;
26807               case 1: //src_1
26808                 return 2;
26809               case 2: //vcc
26810                 return 8;
26811               default:
26812                 fatal("op idx %i out of bounds\n", opIdx);
26813                 return -1;
26814             }
26815         } // getOperandSize
26816
26817         bool
26818         isSrcOperand(int opIdx) override
26819         {
26820             switch (opIdx) {
26821               case 0: //src_0
26822                 return true;
26823               case 1: //src_1
26824                 return true;
26825               case 2: //vcc
26826                 return false;
26827               default:
26828                 fatal("op idx %i out of bounds\n", opIdx);
26829                 return false;
26830             }
26831         } // isSrcOperand
26832
26833         bool
26834         isDstOperand(int opIdx) override
26835         {
26836             switch (opIdx) {
26837               case 0: //src_0
26838                 return false;
26839               case 1: //src_1
26840                 return false;
26841               case 2: //vcc
26842                 return true;
26843               default:
26844                 fatal("op idx %i out of bounds\n", opIdx);
26845                 return false;
26846             }
26847         } // isDstOperand
26848
26849         void execute(GPUDynInstPtr) override;
26850     }; // Inst_VOPC__V_CMP_NE_U16
26851
26852     class Inst_VOPC__V_CMP_GE_U16 : public Inst_VOPC
26853     {
26854       public:
26855         Inst_VOPC__V_CMP_GE_U16(InFmt_VOPC*);
26856         ~Inst_VOPC__V_CMP_GE_U16();
26857
26858         int
26859         getNumOperands() override
26860         {
26861             return numDstRegOperands() + numSrcRegOperands();
26862         } // getNumOperands
26863
26864         int numDstRegOperands() override { return 1; }
26865         int numSrcRegOperands() override { return 2; }
26866
26867         int
26868         getOperandSize(int opIdx) override
26869         {
26870             switch (opIdx) {
26871               case 0: //src_0
26872                 return 2;
26873               case 1: //src_1
26874                 return 2;
26875               case 2: //vcc
26876                 return 8;
26877               default:
26878                 fatal("op idx %i out of bounds\n", opIdx);
26879                 return -1;
26880             }
26881         } // getOperandSize
26882
26883         bool
26884         isSrcOperand(int opIdx) override
26885         {
26886             switch (opIdx) {
26887               case 0: //src_0
26888                 return true;
26889               case 1: //src_1
26890                 return true;
26891               case 2: //vcc
26892                 return false;
26893               default:
26894                 fatal("op idx %i out of bounds\n", opIdx);
26895                 return false;
26896             }
26897         } // isSrcOperand
26898
26899         bool
26900         isDstOperand(int opIdx) override
26901         {
26902             switch (opIdx) {
26903               case 0: //src_0
26904                 return false;
26905               case 1: //src_1
26906                 return false;
26907               case 2: //vcc
26908                 return true;
26909               default:
26910                 fatal("op idx %i out of bounds\n", opIdx);
26911                 return false;
26912             }
26913         } // isDstOperand
26914
26915         void execute(GPUDynInstPtr) override;
26916     }; // Inst_VOPC__V_CMP_GE_U16
26917
26918     class Inst_VOPC__V_CMP_T_U16 : public Inst_VOPC
26919     {
26920       public:
26921         Inst_VOPC__V_CMP_T_U16(InFmt_VOPC*);
26922         ~Inst_VOPC__V_CMP_T_U16();
26923
26924         int
26925         getNumOperands() override
26926         {
26927             return numDstRegOperands() + numSrcRegOperands();
26928         } // getNumOperands
26929
26930         int numDstRegOperands() override { return 1; }
26931         int numSrcRegOperands() override { return 2; }
26932
26933         int
26934         getOperandSize(int opIdx) override
26935         {
26936             switch (opIdx) {
26937               case 0: //src_0
26938                 return 2;
26939               case 1: //src_1
26940                 return 2;
26941               case 2: //vcc
26942                 return 8;
26943               default:
26944                 fatal("op idx %i out of bounds\n", opIdx);
26945                 return -1;
26946             }
26947         } // getOperandSize
26948
26949         bool
26950         isSrcOperand(int opIdx) override
26951         {
26952             switch (opIdx) {
26953               case 0: //src_0
26954                 return true;
26955               case 1: //src_1
26956                 return true;
26957               case 2: //vcc
26958                 return false;
26959               default:
26960                 fatal("op idx %i out of bounds\n", opIdx);
26961                 return false;
26962             }
26963         } // isSrcOperand
26964
26965         bool
26966         isDstOperand(int opIdx) override
26967         {
26968             switch (opIdx) {
26969               case 0: //src_0
26970                 return false;
26971               case 1: //src_1
26972                 return false;
26973               case 2: //vcc
26974                 return true;
26975               default:
26976                 fatal("op idx %i out of bounds\n", opIdx);
26977                 return false;
26978             }
26979         } // isDstOperand
26980
26981         void execute(GPUDynInstPtr) override;
26982     }; // Inst_VOPC__V_CMP_T_U16
26983
26984     class Inst_VOPC__V_CMPX_F_I16 : public Inst_VOPC
26985     {
26986       public:
26987         Inst_VOPC__V_CMPX_F_I16(InFmt_VOPC*);
26988         ~Inst_VOPC__V_CMPX_F_I16();
26989
26990         int
26991         getNumOperands() override
26992         {
26993             return numDstRegOperands() + numSrcRegOperands();
26994         } // getNumOperands
26995
26996         int numDstRegOperands() override { return 1; }
26997         int numSrcRegOperands() override { return 2; }
26998
26999         int
27000         getOperandSize(int opIdx) override
27001         {
27002             switch (opIdx) {
27003               case 0: //src_0
27004                 return 2;
27005               case 1: //src_1
27006                 return 2;
27007               case 2: //vcc
27008                 return 8;
27009               default:
27010                 fatal("op idx %i out of bounds\n", opIdx);
27011                 return -1;
27012             }
27013         } // getOperandSize
27014
27015         bool
27016         isSrcOperand(int opIdx) override
27017         {
27018             switch (opIdx) {
27019               case 0: //src_0
27020                 return true;
27021               case 1: //src_1
27022                 return true;
27023               default:
27024                 fatal("op idx %i out of bounds\n", opIdx);
27025                 return false;
27026             }
27027         } // isSrcOperand
27028
27029         bool
27030         isDstOperand(int opIdx) override
27031         {
27032             switch (opIdx) {
27033               case 0: //src_0
27034                 return false;
27035               case 1: //src_1
27036                 return false;
27037               default:
27038                 fatal("op idx %i out of bounds\n", opIdx);
27039                 return false;
27040             }
27041         } // isDstOperand
27042
27043         void execute(GPUDynInstPtr) override;
27044     }; // Inst_VOPC__V_CMPX_F_I16
27045
27046     class Inst_VOPC__V_CMPX_LT_I16 : public Inst_VOPC
27047     {
27048       public:
27049         Inst_VOPC__V_CMPX_LT_I16(InFmt_VOPC*);
27050         ~Inst_VOPC__V_CMPX_LT_I16();
27051
27052         int
27053         getNumOperands() override
27054         {
27055             return numDstRegOperands() + numSrcRegOperands();
27056         } // getNumOperands
27057
27058         int numDstRegOperands() override { return 1; }
27059         int numSrcRegOperands() override { return 2; }
27060
27061         int
27062         getOperandSize(int opIdx) override
27063         {
27064             switch (opIdx) {
27065               case 0: //src_0
27066                 return 2;
27067               case 1: //src_1
27068                 return 2;
27069               case 2: //vcc
27070                 return 8;
27071               default:
27072                 fatal("op idx %i out of bounds\n", opIdx);
27073                 return -1;
27074             }
27075         } // getOperandSize
27076
27077         bool
27078         isSrcOperand(int opIdx) override
27079         {
27080             switch (opIdx) {
27081               case 0: //src_0
27082                 return true;
27083               case 1: //src_1
27084                 return true;
27085               default:
27086                 fatal("op idx %i out of bounds\n", opIdx);
27087                 return false;
27088             }
27089         } // isSrcOperand
27090
27091         bool
27092         isDstOperand(int opIdx) override
27093         {
27094             switch (opIdx) {
27095               case 0: //src_0
27096                 return false;
27097               case 1: //src_1
27098                 return false;
27099               default:
27100                 fatal("op idx %i out of bounds\n", opIdx);
27101                 return false;
27102             }
27103         } // isDstOperand
27104
27105         void execute(GPUDynInstPtr) override;
27106     }; // Inst_VOPC__V_CMPX_LT_I16
27107
27108     class Inst_VOPC__V_CMPX_EQ_I16 : public Inst_VOPC
27109     {
27110       public:
27111         Inst_VOPC__V_CMPX_EQ_I16(InFmt_VOPC*);
27112         ~Inst_VOPC__V_CMPX_EQ_I16();
27113
27114         int
27115         getNumOperands() override
27116         {
27117             return numDstRegOperands() + numSrcRegOperands();
27118         } // getNumOperands
27119
27120         int numDstRegOperands() override { return 1; }
27121         int numSrcRegOperands() override { return 2; }
27122
27123         int
27124         getOperandSize(int opIdx) override
27125         {
27126             switch (opIdx) {
27127               case 0: //src_0
27128                 return 2;
27129               case 1: //src_1
27130                 return 2;
27131               case 2: //vcc
27132                 return 8;
27133               default:
27134                 fatal("op idx %i out of bounds\n", opIdx);
27135                 return -1;
27136             }
27137         } // getOperandSize
27138
27139         bool
27140         isSrcOperand(int opIdx) override
27141         {
27142             switch (opIdx) {
27143               case 0: //src_0
27144                 return true;
27145               case 1: //src_1
27146                 return true;
27147               default:
27148                 fatal("op idx %i out of bounds\n", opIdx);
27149                 return false;
27150             }
27151         } // isSrcOperand
27152
27153         bool
27154         isDstOperand(int opIdx) override
27155         {
27156             switch (opIdx) {
27157               case 0: //src_0
27158                 return false;
27159               case 1: //src_1
27160                 return false;
27161               default:
27162                 fatal("op idx %i out of bounds\n", opIdx);
27163                 return false;
27164             }
27165         } // isDstOperand
27166
27167         void execute(GPUDynInstPtr) override;
27168     }; // Inst_VOPC__V_CMPX_EQ_I16
27169
27170     class Inst_VOPC__V_CMPX_LE_I16 : public Inst_VOPC
27171     {
27172       public:
27173         Inst_VOPC__V_CMPX_LE_I16(InFmt_VOPC*);
27174         ~Inst_VOPC__V_CMPX_LE_I16();
27175
27176         int
27177         getNumOperands() override
27178         {
27179             return numDstRegOperands() + numSrcRegOperands();
27180         } // getNumOperands
27181
27182         int numDstRegOperands() override { return 1; }
27183         int numSrcRegOperands() override { return 2; }
27184
27185         int
27186         getOperandSize(int opIdx) override
27187         {
27188             switch (opIdx) {
27189               case 0: //src_0
27190                 return 2;
27191               case 1: //src_1
27192                 return 2;
27193               case 2: //vcc
27194                 return 8;
27195               default:
27196                 fatal("op idx %i out of bounds\n", opIdx);
27197                 return -1;
27198             }
27199         } // getOperandSize
27200
27201         bool
27202         isSrcOperand(int opIdx) override
27203         {
27204             switch (opIdx) {
27205               case 0: //src_0
27206                 return true;
27207               case 1: //src_1
27208                 return true;
27209               default:
27210                 fatal("op idx %i out of bounds\n", opIdx);
27211                 return false;
27212             }
27213         } // isSrcOperand
27214
27215         bool
27216         isDstOperand(int opIdx) override
27217         {
27218             switch (opIdx) {
27219               case 0: //src_0
27220                 return false;
27221               case 1: //src_1
27222                 return false;
27223               default:
27224                 fatal("op idx %i out of bounds\n", opIdx);
27225                 return false;
27226             }
27227         } // isDstOperand
27228
27229         void execute(GPUDynInstPtr) override;
27230     }; // Inst_VOPC__V_CMPX_LE_I16
27231
27232     class Inst_VOPC__V_CMPX_GT_I16 : public Inst_VOPC
27233     {
27234       public:
27235         Inst_VOPC__V_CMPX_GT_I16(InFmt_VOPC*);
27236         ~Inst_VOPC__V_CMPX_GT_I16();
27237
27238         int
27239         getNumOperands() override
27240         {
27241             return numDstRegOperands() + numSrcRegOperands();
27242         } // getNumOperands
27243
27244         int numDstRegOperands() override { return 1; }
27245         int numSrcRegOperands() override { return 2; }
27246
27247         int
27248         getOperandSize(int opIdx) override
27249         {
27250             switch (opIdx) {
27251               case 0: //src_0
27252                 return 2;
27253               case 1: //src_1
27254                 return 2;
27255               case 2: //vcc
27256                 return 8;
27257               default:
27258                 fatal("op idx %i out of bounds\n", opIdx);
27259                 return -1;
27260             }
27261         } // getOperandSize
27262
27263         bool
27264         isSrcOperand(int opIdx) override
27265         {
27266             switch (opIdx) {
27267               case 0: //src_0
27268                 return true;
27269               case 1: //src_1
27270                 return true;
27271               default:
27272                 fatal("op idx %i out of bounds\n", opIdx);
27273                 return false;
27274             }
27275         } // isSrcOperand
27276
27277         bool
27278         isDstOperand(int opIdx) override
27279         {
27280             switch (opIdx) {
27281               case 0: //src_0
27282                 return false;
27283               case 1: //src_1
27284                 return false;
27285               default:
27286                 fatal("op idx %i out of bounds\n", opIdx);
27287                 return false;
27288             }
27289         } // isDstOperand
27290
27291         void execute(GPUDynInstPtr) override;
27292     }; // Inst_VOPC__V_CMPX_GT_I16
27293
27294     class Inst_VOPC__V_CMPX_NE_I16 : public Inst_VOPC
27295     {
27296       public:
27297         Inst_VOPC__V_CMPX_NE_I16(InFmt_VOPC*);
27298         ~Inst_VOPC__V_CMPX_NE_I16();
27299
27300         int
27301         getNumOperands() override
27302         {
27303             return numDstRegOperands() + numSrcRegOperands();
27304         } // getNumOperands
27305
27306         int numDstRegOperands() override { return 1; }
27307         int numSrcRegOperands() override { return 2; }
27308
27309         int
27310         getOperandSize(int opIdx) override
27311         {
27312             switch (opIdx) {
27313               case 0: //src_0
27314                 return 2;
27315               case 1: //src_1
27316                 return 2;
27317               case 2: //vcc
27318                 return 8;
27319               default:
27320                 fatal("op idx %i out of bounds\n", opIdx);
27321                 return -1;
27322             }
27323         } // getOperandSize
27324
27325         bool
27326         isSrcOperand(int opIdx) override
27327         {
27328             switch (opIdx) {
27329               case 0: //src_0
27330                 return true;
27331               case 1: //src_1
27332                 return true;
27333               default:
27334                 fatal("op idx %i out of bounds\n", opIdx);
27335                 return false;
27336             }
27337         } // isSrcOperand
27338
27339         bool
27340         isDstOperand(int opIdx) override
27341         {
27342             switch (opIdx) {
27343               case 0: //src_0
27344                 return false;
27345               case 1: //src_1
27346                 return false;
27347               default:
27348                 fatal("op idx %i out of bounds\n", opIdx);
27349                 return false;
27350             }
27351         } // isDstOperand
27352
27353         void execute(GPUDynInstPtr) override;
27354     }; // Inst_VOPC__V_CMPX_NE_I16
27355
27356     class Inst_VOPC__V_CMPX_GE_I16 : public Inst_VOPC
27357     {
27358       public:
27359         Inst_VOPC__V_CMPX_GE_I16(InFmt_VOPC*);
27360         ~Inst_VOPC__V_CMPX_GE_I16();
27361
27362         int
27363         getNumOperands() override
27364         {
27365             return numDstRegOperands() + numSrcRegOperands();
27366         } // getNumOperands
27367
27368         int numDstRegOperands() override { return 1; }
27369         int numSrcRegOperands() override { return 2; }
27370
27371         int
27372         getOperandSize(int opIdx) override
27373         {
27374             switch (opIdx) {
27375               case 0: //src_0
27376                 return 2;
27377               case 1: //src_1
27378                 return 2;
27379               case 2: //vcc
27380                 return 8;
27381               default:
27382                 fatal("op idx %i out of bounds\n", opIdx);
27383                 return -1;
27384             }
27385         } // getOperandSize
27386
27387         bool
27388         isSrcOperand(int opIdx) override
27389         {
27390             switch (opIdx) {
27391               case 0: //src_0
27392                 return true;
27393               case 1: //src_1
27394                 return true;
27395               default:
27396                 fatal("op idx %i out of bounds\n", opIdx);
27397                 return false;
27398             }
27399         } // isSrcOperand
27400
27401         bool
27402         isDstOperand(int opIdx) override
27403         {
27404             switch (opIdx) {
27405               case 0: //src_0
27406                 return false;
27407               case 1: //src_1
27408                 return false;
27409               default:
27410                 fatal("op idx %i out of bounds\n", opIdx);
27411                 return false;
27412             }
27413         } // isDstOperand
27414
27415         void execute(GPUDynInstPtr) override;
27416     }; // Inst_VOPC__V_CMPX_GE_I16
27417
27418     class Inst_VOPC__V_CMPX_T_I16 : public Inst_VOPC
27419     {
27420       public:
27421         Inst_VOPC__V_CMPX_T_I16(InFmt_VOPC*);
27422         ~Inst_VOPC__V_CMPX_T_I16();
27423
27424         int
27425         getNumOperands() override
27426         {
27427             return numDstRegOperands() + numSrcRegOperands();
27428         } // getNumOperands
27429
27430         int numDstRegOperands() override { return 1; }
27431         int numSrcRegOperands() override { return 2; }
27432
27433         int
27434         getOperandSize(int opIdx) override
27435         {
27436             switch (opIdx) {
27437               case 0: //src_0
27438                 return 2;
27439               case 1: //src_1
27440                 return 2;
27441               case 2: //vcc
27442                 return 8;
27443               default:
27444                 fatal("op idx %i out of bounds\n", opIdx);
27445                 return -1;
27446             }
27447         } // getOperandSize
27448
27449         bool
27450         isSrcOperand(int opIdx) override
27451         {
27452             switch (opIdx) {
27453               case 0: //src_0
27454                 return true;
27455               case 1: //src_1
27456                 return true;
27457               default:
27458                 fatal("op idx %i out of bounds\n", opIdx);
27459                 return false;
27460             }
27461         } // isSrcOperand
27462
27463         bool
27464         isDstOperand(int opIdx) override
27465         {
27466             switch (opIdx) {
27467               case 0: //src_0
27468                 return false;
27469               case 1: //src_1
27470                 return false;
27471               default:
27472                 fatal("op idx %i out of bounds\n", opIdx);
27473                 return false;
27474             }
27475         } // isDstOperand
27476
27477         void execute(GPUDynInstPtr) override;
27478     }; // Inst_VOPC__V_CMPX_T_I16
27479
27480     class Inst_VOPC__V_CMPX_F_U16 : public Inst_VOPC
27481     {
27482       public:
27483         Inst_VOPC__V_CMPX_F_U16(InFmt_VOPC*);
27484         ~Inst_VOPC__V_CMPX_F_U16();
27485
27486         int
27487         getNumOperands() override
27488         {
27489             return numDstRegOperands() + numSrcRegOperands();
27490         } // getNumOperands
27491
27492         int numDstRegOperands() override { return 1; }
27493         int numSrcRegOperands() override { return 2; }
27494
27495         int
27496         getOperandSize(int opIdx) override
27497         {
27498             switch (opIdx) {
27499               case 0: //src_0
27500                 return 2;
27501               case 1: //src_1
27502                 return 2;
27503               case 2: //vcc
27504                 return 8;
27505               default:
27506                 fatal("op idx %i out of bounds\n", opIdx);
27507                 return -1;
27508             }
27509         } // getOperandSize
27510
27511         bool
27512         isSrcOperand(int opIdx) override
27513         {
27514             switch (opIdx) {
27515               case 0: //src_0
27516                 return true;
27517               case 1: //src_1
27518                 return true;
27519               default:
27520                 fatal("op idx %i out of bounds\n", opIdx);
27521                 return false;
27522             }
27523         } // isSrcOperand
27524
27525         bool
27526         isDstOperand(int opIdx) override
27527         {
27528             switch (opIdx) {
27529               case 0: //src_0
27530                 return false;
27531               case 1: //src_1
27532                 return false;
27533               default:
27534                 fatal("op idx %i out of bounds\n", opIdx);
27535                 return false;
27536             }
27537         } // isDstOperand
27538
27539         void execute(GPUDynInstPtr) override;
27540     }; // Inst_VOPC__V_CMPX_F_U16
27541
27542     class Inst_VOPC__V_CMPX_LT_U16 : public Inst_VOPC
27543     {
27544       public:
27545         Inst_VOPC__V_CMPX_LT_U16(InFmt_VOPC*);
27546         ~Inst_VOPC__V_CMPX_LT_U16();
27547
27548         int
27549         getNumOperands() override
27550         {
27551             return numDstRegOperands() + numSrcRegOperands();
27552         } // getNumOperands
27553
27554         int numDstRegOperands() override { return 1; }
27555         int numSrcRegOperands() override { return 2; }
27556
27557         int
27558         getOperandSize(int opIdx) override
27559         {
27560             switch (opIdx) {
27561               case 0: //src_0
27562                 return 2;
27563               case 1: //src_1
27564                 return 2;
27565               case 2: //vcc
27566                 return 8;
27567               default:
27568                 fatal("op idx %i out of bounds\n", opIdx);
27569                 return -1;
27570             }
27571         } // getOperandSize
27572
27573         bool
27574         isSrcOperand(int opIdx) override
27575         {
27576             switch (opIdx) {
27577               case 0: //src_0
27578                 return true;
27579               case 1: //src_1
27580                 return true;
27581               default:
27582                 fatal("op idx %i out of bounds\n", opIdx);
27583                 return false;
27584             }
27585         } // isSrcOperand
27586
27587         bool
27588         isDstOperand(int opIdx) override
27589         {
27590             switch (opIdx) {
27591               case 0: //src_0
27592                 return false;
27593               case 1: //src_1
27594                 return false;
27595               default:
27596                 fatal("op idx %i out of bounds\n", opIdx);
27597                 return false;
27598             }
27599         } // isDstOperand
27600
27601         void execute(GPUDynInstPtr) override;
27602     }; // Inst_VOPC__V_CMPX_LT_U16
27603
27604     class Inst_VOPC__V_CMPX_EQ_U16 : public Inst_VOPC
27605     {
27606       public:
27607         Inst_VOPC__V_CMPX_EQ_U16(InFmt_VOPC*);
27608         ~Inst_VOPC__V_CMPX_EQ_U16();
27609
27610         int
27611         getNumOperands() override
27612         {
27613             return numDstRegOperands() + numSrcRegOperands();
27614         } // getNumOperands
27615
27616         int numDstRegOperands() override { return 1; }
27617         int numSrcRegOperands() override { return 2; }
27618
27619         int
27620         getOperandSize(int opIdx) override
27621         {
27622             switch (opIdx) {
27623               case 0: //src_0
27624                 return 2;
27625               case 1: //src_1
27626                 return 2;
27627               case 2: //vcc
27628                 return 8;
27629               default:
27630                 fatal("op idx %i out of bounds\n", opIdx);
27631                 return -1;
27632             }
27633         } // getOperandSize
27634
27635         bool
27636         isSrcOperand(int opIdx) override
27637         {
27638             switch (opIdx) {
27639               case 0: //src_0
27640                 return true;
27641               case 1: //src_1
27642                 return true;
27643               default:
27644                 fatal("op idx %i out of bounds\n", opIdx);
27645                 return false;
27646             }
27647         } // isSrcOperand
27648
27649         bool
27650         isDstOperand(int opIdx) override
27651         {
27652             switch (opIdx) {
27653               case 0: //src_0
27654                 return false;
27655               case 1: //src_1
27656                 return false;
27657               default:
27658                 fatal("op idx %i out of bounds\n", opIdx);
27659                 return false;
27660             }
27661         } // isDstOperand
27662
27663         void execute(GPUDynInstPtr) override;
27664     }; // Inst_VOPC__V_CMPX_EQ_U16
27665
27666     class Inst_VOPC__V_CMPX_LE_U16 : public Inst_VOPC
27667     {
27668       public:
27669         Inst_VOPC__V_CMPX_LE_U16(InFmt_VOPC*);
27670         ~Inst_VOPC__V_CMPX_LE_U16();
27671
27672         int
27673         getNumOperands() override
27674         {
27675             return numDstRegOperands() + numSrcRegOperands();
27676         } // getNumOperands
27677
27678         int numDstRegOperands() override { return 1; }
27679         int numSrcRegOperands() override { return 2; }
27680
27681         int
27682         getOperandSize(int opIdx) override
27683         {
27684             switch (opIdx) {
27685               case 0: //src_0
27686                 return 2;
27687               case 1: //src_1
27688                 return 2;
27689               case 2: //vcc
27690                 return 8;
27691               default:
27692                 fatal("op idx %i out of bounds\n", opIdx);
27693                 return -1;
27694             }
27695         } // getOperandSize
27696
27697         bool
27698         isSrcOperand(int opIdx) override
27699         {
27700             switch (opIdx) {
27701               case 0: //src_0
27702                 return true;
27703               case 1: //src_1
27704                 return true;
27705               default:
27706                 fatal("op idx %i out of bounds\n", opIdx);
27707                 return false;
27708             }
27709         } // isSrcOperand
27710
27711         bool
27712         isDstOperand(int opIdx) override
27713         {
27714             switch (opIdx) {
27715               case 0: //src_0
27716                 return false;
27717               case 1: //src_1
27718                 return false;
27719               default:
27720                 fatal("op idx %i out of bounds\n", opIdx);
27721                 return false;
27722             }
27723         } // isDstOperand
27724
27725         void execute(GPUDynInstPtr) override;
27726     }; // Inst_VOPC__V_CMPX_LE_U16
27727
27728     class Inst_VOPC__V_CMPX_GT_U16 : public Inst_VOPC
27729     {
27730       public:
27731         Inst_VOPC__V_CMPX_GT_U16(InFmt_VOPC*);
27732         ~Inst_VOPC__V_CMPX_GT_U16();
27733
27734         int
27735         getNumOperands() override
27736         {
27737             return numDstRegOperands() + numSrcRegOperands();
27738         } // getNumOperands
27739
27740         int numDstRegOperands() override { return 1; }
27741         int numSrcRegOperands() override { return 2; }
27742
27743         int
27744         getOperandSize(int opIdx) override
27745         {
27746             switch (opIdx) {
27747               case 0: //src_0
27748                 return 2;
27749               case 1: //src_1
27750                 return 2;
27751               case 2: //vcc
27752                 return 8;
27753               default:
27754                 fatal("op idx %i out of bounds\n", opIdx);
27755                 return -1;
27756             }
27757         } // getOperandSize
27758
27759         bool
27760         isSrcOperand(int opIdx) override
27761         {
27762             switch (opIdx) {
27763               case 0: //src_0
27764                 return true;
27765               case 1: //src_1
27766                 return true;
27767               default:
27768                 fatal("op idx %i out of bounds\n", opIdx);
27769                 return false;
27770             }
27771         } // isSrcOperand
27772
27773         bool
27774         isDstOperand(int opIdx) override
27775         {
27776             switch (opIdx) {
27777               case 0: //src_0
27778                 return false;
27779               case 1: //src_1
27780                 return false;
27781               default:
27782                 fatal("op idx %i out of bounds\n", opIdx);
27783                 return false;
27784             }
27785         } // isDstOperand
27786
27787         void execute(GPUDynInstPtr) override;
27788     }; // Inst_VOPC__V_CMPX_GT_U16
27789
27790     class Inst_VOPC__V_CMPX_NE_U16 : public Inst_VOPC
27791     {
27792       public:
27793         Inst_VOPC__V_CMPX_NE_U16(InFmt_VOPC*);
27794         ~Inst_VOPC__V_CMPX_NE_U16();
27795
27796         int
27797         getNumOperands() override
27798         {
27799             return numDstRegOperands() + numSrcRegOperands();
27800         } // getNumOperands
27801
27802         int numDstRegOperands() override { return 1; }
27803         int numSrcRegOperands() override { return 2; }
27804
27805         int
27806         getOperandSize(int opIdx) override
27807         {
27808             switch (opIdx) {
27809               case 0: //src_0
27810                 return 2;
27811               case 1: //src_1
27812                 return 2;
27813               case 2: //vcc
27814                 return 8;
27815               default:
27816                 fatal("op idx %i out of bounds\n", opIdx);
27817                 return -1;
27818             }
27819         } // getOperandSize
27820
27821         bool
27822         isSrcOperand(int opIdx) override
27823         {
27824             switch (opIdx) {
27825               case 0: //src_0
27826                 return true;
27827               case 1: //src_1
27828                 return true;
27829               default:
27830                 fatal("op idx %i out of bounds\n", opIdx);
27831                 return false;
27832             }
27833         } // isSrcOperand
27834
27835         bool
27836         isDstOperand(int opIdx) override
27837         {
27838             switch (opIdx) {
27839               case 0: //src_0
27840                 return false;
27841               case 1: //src_1
27842                 return false;
27843               default:
27844                 fatal("op idx %i out of bounds\n", opIdx);
27845                 return false;
27846             }
27847         } // isDstOperand
27848
27849         void execute(GPUDynInstPtr) override;
27850     }; // Inst_VOPC__V_CMPX_NE_U16
27851
27852     class Inst_VOPC__V_CMPX_GE_U16 : public Inst_VOPC
27853     {
27854       public:
27855         Inst_VOPC__V_CMPX_GE_U16(InFmt_VOPC*);
27856         ~Inst_VOPC__V_CMPX_GE_U16();
27857
27858         int
27859         getNumOperands() override
27860         {
27861             return numDstRegOperands() + numSrcRegOperands();
27862         } // getNumOperands
27863
27864         int numDstRegOperands() override { return 1; }
27865         int numSrcRegOperands() override { return 2; }
27866
27867         int
27868         getOperandSize(int opIdx) override
27869         {
27870             switch (opIdx) {
27871               case 0: //src_0
27872                 return 2;
27873               case 1: //src_1
27874                 return 2;
27875               case 2: //vcc
27876                 return 8;
27877               default:
27878                 fatal("op idx %i out of bounds\n", opIdx);
27879                 return -1;
27880             }
27881         } // getOperandSize
27882
27883         bool
27884         isSrcOperand(int opIdx) override
27885         {
27886             switch (opIdx) {
27887               case 0: //src_0
27888                 return true;
27889               case 1: //src_1
27890                 return true;
27891               default:
27892                 fatal("op idx %i out of bounds\n", opIdx);
27893                 return false;
27894             }
27895         } // isSrcOperand
27896
27897         bool
27898         isDstOperand(int opIdx) override
27899         {
27900             switch (opIdx) {
27901               case 0: //src_0
27902                 return false;
27903               case 1: //src_1
27904                 return false;
27905               default:
27906                 fatal("op idx %i out of bounds\n", opIdx);
27907                 return false;
27908             }
27909         } // isDstOperand
27910
27911         void execute(GPUDynInstPtr) override;
27912     }; // Inst_VOPC__V_CMPX_GE_U16
27913
27914     class Inst_VOPC__V_CMPX_T_U16 : public Inst_VOPC
27915     {
27916       public:
27917         Inst_VOPC__V_CMPX_T_U16(InFmt_VOPC*);
27918         ~Inst_VOPC__V_CMPX_T_U16();
27919
27920         int
27921         getNumOperands() override
27922         {
27923             return numDstRegOperands() + numSrcRegOperands();
27924         } // getNumOperands
27925
27926         int numDstRegOperands() override { return 1; }
27927         int numSrcRegOperands() override { return 2; }
27928
27929         int
27930         getOperandSize(int opIdx) override
27931         {
27932             switch (opIdx) {
27933               case 0: //src_0
27934                 return 2;
27935               case 1: //src_1
27936                 return 2;
27937               case 2: //vcc
27938                 return 8;
27939               default:
27940                 fatal("op idx %i out of bounds\n", opIdx);
27941                 return -1;
27942             }
27943         } // getOperandSize
27944
27945         bool
27946         isSrcOperand(int opIdx) override
27947         {
27948             switch (opIdx) {
27949               case 0: //src_0
27950                 return true;
27951               case 1: //src_1
27952                 return true;
27953               default:
27954                 fatal("op idx %i out of bounds\n", opIdx);
27955                 return false;
27956             }
27957         } // isSrcOperand
27958
27959         bool
27960         isDstOperand(int opIdx) override
27961         {
27962             switch (opIdx) {
27963               case 0: //src_0
27964                 return false;
27965               case 1: //src_1
27966                 return false;
27967               default:
27968                 fatal("op idx %i out of bounds\n", opIdx);
27969                 return false;
27970             }
27971         } // isDstOperand
27972
27973         void execute(GPUDynInstPtr) override;
27974     }; // Inst_VOPC__V_CMPX_T_U16
27975
27976     class Inst_VOPC__V_CMP_F_I32 : public Inst_VOPC
27977     {
27978       public:
27979         Inst_VOPC__V_CMP_F_I32(InFmt_VOPC*);
27980         ~Inst_VOPC__V_CMP_F_I32();
27981
27982         int
27983         getNumOperands() override
27984         {
27985             return numDstRegOperands() + numSrcRegOperands();
27986         } // getNumOperands
27987
27988         int numDstRegOperands() override { return 1; }
27989         int numSrcRegOperands() override { return 2; }
27990
27991         int
27992         getOperandSize(int opIdx) override
27993         {
27994             switch (opIdx) {
27995               case 0: //src_0
27996                 return 4;
27997               case 1: //src_1
27998                 return 4;
27999               case 2: //vcc
28000                 return 8;
28001               default:
28002                 fatal("op idx %i out of bounds\n", opIdx);
28003                 return -1;
28004             }
28005         } // getOperandSize
28006
28007         bool
28008         isSrcOperand(int opIdx) override
28009         {
28010             switch (opIdx) {
28011               case 0: //src_0
28012                 return true;
28013               case 1: //src_1
28014                 return true;
28015               case 2: //vcc
28016                 return false;
28017               default:
28018                 fatal("op idx %i out of bounds\n", opIdx);
28019                 return false;
28020             }
28021         } // isSrcOperand
28022
28023         bool
28024         isDstOperand(int opIdx) override
28025         {
28026             switch (opIdx) {
28027               case 0: //src_0
28028                 return false;
28029               case 1: //src_1
28030                 return false;
28031               case 2: //vcc
28032                 return true;
28033               default:
28034                 fatal("op idx %i out of bounds\n", opIdx);
28035                 return false;
28036             }
28037         } // isDstOperand
28038
28039         void execute(GPUDynInstPtr) override;
28040     }; // Inst_VOPC__V_CMP_F_I32
28041
28042     class Inst_VOPC__V_CMP_LT_I32 : public Inst_VOPC
28043     {
28044       public:
28045         Inst_VOPC__V_CMP_LT_I32(InFmt_VOPC*);
28046         ~Inst_VOPC__V_CMP_LT_I32();
28047
28048         int
28049         getNumOperands() override
28050         {
28051             return numDstRegOperands() + numSrcRegOperands();
28052         } // getNumOperands
28053
28054         int numDstRegOperands() override { return 1; }
28055         int numSrcRegOperands() override { return 2; }
28056
28057         int
28058         getOperandSize(int opIdx) override
28059         {
28060             switch (opIdx) {
28061               case 0: //src_0
28062                 return 4;
28063               case 1: //src_1
28064                 return 4;
28065               case 2: //vcc
28066                 return 8;
28067               default:
28068                 fatal("op idx %i out of bounds\n", opIdx);
28069                 return -1;
28070             }
28071         } // getOperandSize
28072
28073         bool
28074         isSrcOperand(int opIdx) override
28075         {
28076             switch (opIdx) {
28077               case 0: //src_0
28078                 return true;
28079               case 1: //src_1
28080                 return true;
28081               case 2: //vcc
28082                 return false;
28083               default:
28084                 fatal("op idx %i out of bounds\n", opIdx);
28085                 return false;
28086             }
28087         } // isSrcOperand
28088
28089         bool
28090         isDstOperand(int opIdx) override
28091         {
28092             switch (opIdx) {
28093               case 0: //src_0
28094                 return false;
28095               case 1: //src_1
28096                 return false;
28097               case 2: //vcc
28098                 return true;
28099               default:
28100                 fatal("op idx %i out of bounds\n", opIdx);
28101                 return false;
28102             }
28103         } // isDstOperand
28104
28105         void execute(GPUDynInstPtr) override;
28106     }; // Inst_VOPC__V_CMP_LT_I32
28107
28108     class Inst_VOPC__V_CMP_EQ_I32 : public Inst_VOPC
28109     {
28110       public:
28111         Inst_VOPC__V_CMP_EQ_I32(InFmt_VOPC*);
28112         ~Inst_VOPC__V_CMP_EQ_I32();
28113
28114         int
28115         getNumOperands() override
28116         {
28117             return numDstRegOperands() + numSrcRegOperands();
28118         } // getNumOperands
28119
28120         int numDstRegOperands() override { return 1; }
28121         int numSrcRegOperands() override { return 2; }
28122
28123         int
28124         getOperandSize(int opIdx) override
28125         {
28126             switch (opIdx) {
28127               case 0: //src_0
28128                 return 4;
28129               case 1: //src_1
28130                 return 4;
28131               case 2: //vcc
28132                 return 8;
28133               default:
28134                 fatal("op idx %i out of bounds\n", opIdx);
28135                 return -1;
28136             }
28137         } // getOperandSize
28138
28139         bool
28140         isSrcOperand(int opIdx) override
28141         {
28142             switch (opIdx) {
28143               case 0: //src_0
28144                 return true;
28145               case 1: //src_1
28146                 return true;
28147               case 2: //vcc
28148                 return false;
28149               default:
28150                 fatal("op idx %i out of bounds\n", opIdx);
28151                 return false;
28152             }
28153         } // isSrcOperand
28154
28155         bool
28156         isDstOperand(int opIdx) override
28157         {
28158             switch (opIdx) {
28159               case 0: //src_0
28160                 return false;
28161               case 1: //src_1
28162                 return false;
28163               case 2: //vcc
28164                 return true;
28165               default:
28166                 fatal("op idx %i out of bounds\n", opIdx);
28167                 return false;
28168             }
28169         } // isDstOperand
28170
28171         void execute(GPUDynInstPtr) override;
28172     }; // Inst_VOPC__V_CMP_EQ_I32
28173
28174     class Inst_VOPC__V_CMP_LE_I32 : public Inst_VOPC
28175     {
28176       public:
28177         Inst_VOPC__V_CMP_LE_I32(InFmt_VOPC*);
28178         ~Inst_VOPC__V_CMP_LE_I32();
28179
28180         int
28181         getNumOperands() override
28182         {
28183             return numDstRegOperands() + numSrcRegOperands();
28184         } // getNumOperands
28185
28186         int numDstRegOperands() override { return 1; }
28187         int numSrcRegOperands() override { return 2; }
28188
28189         int
28190         getOperandSize(int opIdx) override
28191         {
28192             switch (opIdx) {
28193               case 0: //src_0
28194                 return 4;
28195               case 1: //src_1
28196                 return 4;
28197               case 2: //vcc
28198                 return 8;
28199               default:
28200                 fatal("op idx %i out of bounds\n", opIdx);
28201                 return -1;
28202             }
28203         } // getOperandSize
28204
28205         bool
28206         isSrcOperand(int opIdx) override
28207         {
28208             switch (opIdx) {
28209               case 0: //src_0
28210                 return true;
28211               case 1: //src_1
28212                 return true;
28213               case 2: //vcc
28214                 return false;
28215               default:
28216                 fatal("op idx %i out of bounds\n", opIdx);
28217                 return false;
28218             }
28219         } // isSrcOperand
28220
28221         bool
28222         isDstOperand(int opIdx) override
28223         {
28224             switch (opIdx) {
28225               case 0: //src_0
28226                 return false;
28227               case 1: //src_1
28228                 return false;
28229               case 2: //vcc
28230                 return true;
28231               default:
28232                 fatal("op idx %i out of bounds\n", opIdx);
28233                 return false;
28234             }
28235         } // isDstOperand
28236
28237         void execute(GPUDynInstPtr) override;
28238     }; // Inst_VOPC__V_CMP_LE_I32
28239
28240     class Inst_VOPC__V_CMP_GT_I32 : public Inst_VOPC
28241     {
28242       public:
28243         Inst_VOPC__V_CMP_GT_I32(InFmt_VOPC*);
28244         ~Inst_VOPC__V_CMP_GT_I32();
28245
28246         int
28247         getNumOperands() override
28248         {
28249             return numDstRegOperands() + numSrcRegOperands();
28250         } // getNumOperands
28251
28252         int numDstRegOperands() override { return 1; }
28253         int numSrcRegOperands() override { return 2; }
28254
28255         int
28256         getOperandSize(int opIdx) override
28257         {
28258             switch (opIdx) {
28259               case 0: //src_0
28260                 return 4;
28261               case 1: //src_1
28262                 return 4;
28263               case 2: //vcc
28264                 return 8;
28265               default:
28266                 fatal("op idx %i out of bounds\n", opIdx);
28267                 return -1;
28268             }
28269         } // getOperandSize
28270
28271         bool
28272         isSrcOperand(int opIdx) override
28273         {
28274             switch (opIdx) {
28275               case 0: //src_0
28276                 return true;
28277               case 1: //src_1
28278                 return true;
28279               case 2: //vcc
28280                 return false;
28281               default:
28282                 fatal("op idx %i out of bounds\n", opIdx);
28283                 return false;
28284             }
28285         } // isSrcOperand
28286
28287         bool
28288         isDstOperand(int opIdx) override
28289         {
28290             switch (opIdx) {
28291               case 0: //src_0
28292                 return false;
28293               case 1: //src_1
28294                 return false;
28295               case 2: //vcc
28296                 return true;
28297               default:
28298                 fatal("op idx %i out of bounds\n", opIdx);
28299                 return false;
28300             }
28301         } // isDstOperand
28302
28303         void execute(GPUDynInstPtr) override;
28304     }; // Inst_VOPC__V_CMP_GT_I32
28305
28306     class Inst_VOPC__V_CMP_NE_I32 : public Inst_VOPC
28307     {
28308       public:
28309         Inst_VOPC__V_CMP_NE_I32(InFmt_VOPC*);
28310         ~Inst_VOPC__V_CMP_NE_I32();
28311
28312         int
28313         getNumOperands() override
28314         {
28315             return numDstRegOperands() + numSrcRegOperands();
28316         } // getNumOperands
28317
28318         int numDstRegOperands() override { return 1; }
28319         int numSrcRegOperands() override { return 2; }
28320
28321         int
28322         getOperandSize(int opIdx) override
28323         {
28324             switch (opIdx) {
28325               case 0: //src_0
28326                 return 4;
28327               case 1: //src_1
28328                 return 4;
28329               case 2: //vcc
28330                 return 8;
28331               default:
28332                 fatal("op idx %i out of bounds\n", opIdx);
28333                 return -1;
28334             }
28335         } // getOperandSize
28336
28337         bool
28338         isSrcOperand(int opIdx) override
28339         {
28340             switch (opIdx) {
28341               case 0: //src_0
28342                 return true;
28343               case 1: //src_1
28344                 return true;
28345               case 2: //vcc
28346                 return false;
28347               default:
28348                 fatal("op idx %i out of bounds\n", opIdx);
28349                 return false;
28350             }
28351         } // isSrcOperand
28352
28353         bool
28354         isDstOperand(int opIdx) override
28355         {
28356             switch (opIdx) {
28357               case 0: //src_0
28358                 return false;
28359               case 1: //src_1
28360                 return false;
28361               case 2: //vcc
28362                 return true;
28363               default:
28364                 fatal("op idx %i out of bounds\n", opIdx);
28365                 return false;
28366             }
28367         } // isDstOperand
28368
28369         void execute(GPUDynInstPtr) override;
28370     }; // Inst_VOPC__V_CMP_NE_I32
28371
28372     class Inst_VOPC__V_CMP_GE_I32 : public Inst_VOPC
28373     {
28374       public:
28375         Inst_VOPC__V_CMP_GE_I32(InFmt_VOPC*);
28376         ~Inst_VOPC__V_CMP_GE_I32();
28377
28378         int
28379         getNumOperands() override
28380         {
28381             return numDstRegOperands() + numSrcRegOperands();
28382         } // getNumOperands
28383
28384         int numDstRegOperands() override { return 1; }
28385         int numSrcRegOperands() override { return 2; }
28386
28387         int
28388         getOperandSize(int opIdx) override
28389         {
28390             switch (opIdx) {
28391               case 0: //src_0
28392                 return 4;
28393               case 1: //src_1
28394                 return 4;
28395               case 2: //vcc
28396                 return 8;
28397               default:
28398                 fatal("op idx %i out of bounds\n", opIdx);
28399                 return -1;
28400             }
28401         } // getOperandSize
28402
28403         bool
28404         isSrcOperand(int opIdx) override
28405         {
28406             switch (opIdx) {
28407               case 0: //src_0
28408                 return true;
28409               case 1: //src_1
28410                 return true;
28411               case 2: //vcc
28412                 return false;
28413               default:
28414                 fatal("op idx %i out of bounds\n", opIdx);
28415                 return false;
28416             }
28417         } // isSrcOperand
28418
28419         bool
28420         isDstOperand(int opIdx) override
28421         {
28422             switch (opIdx) {
28423               case 0: //src_0
28424                 return false;
28425               case 1: //src_1
28426                 return false;
28427               case 2: //vcc
28428                 return true;
28429               default:
28430                 fatal("op idx %i out of bounds\n", opIdx);
28431                 return false;
28432             }
28433         } // isDstOperand
28434
28435         void execute(GPUDynInstPtr) override;
28436     }; // Inst_VOPC__V_CMP_GE_I32
28437
28438     class Inst_VOPC__V_CMP_T_I32 : public Inst_VOPC
28439     {
28440       public:
28441         Inst_VOPC__V_CMP_T_I32(InFmt_VOPC*);
28442         ~Inst_VOPC__V_CMP_T_I32();
28443
28444         int
28445         getNumOperands() override
28446         {
28447             return numDstRegOperands() + numSrcRegOperands();
28448         } // getNumOperands
28449
28450         int numDstRegOperands() override { return 1; }
28451         int numSrcRegOperands() override { return 2; }
28452
28453         int
28454         getOperandSize(int opIdx) override
28455         {
28456             switch (opIdx) {
28457               case 0: //src_0
28458                 return 4;
28459               case 1: //src_1
28460                 return 4;
28461               case 2: //vcc
28462                 return 8;
28463               default:
28464                 fatal("op idx %i out of bounds\n", opIdx);
28465                 return -1;
28466             }
28467         } // getOperandSize
28468
28469         bool
28470         isSrcOperand(int opIdx) override
28471         {
28472             switch (opIdx) {
28473               case 0: //src_0
28474                 return true;
28475               case 1: //src_1
28476                 return true;
28477               case 2: //vcc
28478                 return false;
28479               default:
28480                 fatal("op idx %i out of bounds\n", opIdx);
28481                 return false;
28482             }
28483         } // isSrcOperand
28484
28485         bool
28486         isDstOperand(int opIdx) override
28487         {
28488             switch (opIdx) {
28489               case 0: //src_0
28490                 return false;
28491               case 1: //src_1
28492                 return false;
28493               case 2: //vcc
28494                 return true;
28495               default:
28496                 fatal("op idx %i out of bounds\n", opIdx);
28497                 return false;
28498             }
28499         } // isDstOperand
28500
28501         void execute(GPUDynInstPtr) override;
28502     }; // Inst_VOPC__V_CMP_T_I32
28503
28504     class Inst_VOPC__V_CMP_F_U32 : public Inst_VOPC
28505     {
28506       public:
28507         Inst_VOPC__V_CMP_F_U32(InFmt_VOPC*);
28508         ~Inst_VOPC__V_CMP_F_U32();
28509
28510         int
28511         getNumOperands() override
28512         {
28513             return numDstRegOperands() + numSrcRegOperands();
28514         } // getNumOperands
28515
28516         int numDstRegOperands() override { return 1; }
28517         int numSrcRegOperands() override { return 2; }
28518
28519         int
28520         getOperandSize(int opIdx) override
28521         {
28522             switch (opIdx) {
28523               case 0: //src_0
28524                 return 4;
28525               case 1: //src_1
28526                 return 4;
28527               case 2: //vcc
28528                 return 8;
28529               default:
28530                 fatal("op idx %i out of bounds\n", opIdx);
28531                 return -1;
28532             }
28533         } // getOperandSize
28534
28535         bool
28536         isSrcOperand(int opIdx) override
28537         {
28538             switch (opIdx) {
28539               case 0: //src_0
28540                 return true;
28541               case 1: //src_1
28542                 return true;
28543               case 2: //vcc
28544                 return false;
28545               default:
28546                 fatal("op idx %i out of bounds\n", opIdx);
28547                 return false;
28548             }
28549         } // isSrcOperand
28550
28551         bool
28552         isDstOperand(int opIdx) override
28553         {
28554             switch (opIdx) {
28555               case 0: //src_0
28556                 return false;
28557               case 1: //src_1
28558                 return false;
28559               case 2: //vcc
28560                 return true;
28561               default:
28562                 fatal("op idx %i out of bounds\n", opIdx);
28563                 return false;
28564             }
28565         } // isDstOperand
28566
28567         void execute(GPUDynInstPtr) override;
28568     }; // Inst_VOPC__V_CMP_F_U32
28569
28570     class Inst_VOPC__V_CMP_LT_U32 : public Inst_VOPC
28571     {
28572       public:
28573         Inst_VOPC__V_CMP_LT_U32(InFmt_VOPC*);
28574         ~Inst_VOPC__V_CMP_LT_U32();
28575
28576         int
28577         getNumOperands() override
28578         {
28579             return numDstRegOperands() + numSrcRegOperands();
28580         } // getNumOperands
28581
28582         int numDstRegOperands() override { return 1; }
28583         int numSrcRegOperands() override { return 2; }
28584
28585         int
28586         getOperandSize(int opIdx) override
28587         {
28588             switch (opIdx) {
28589               case 0: //src_0
28590                 return 4;
28591               case 1: //src_1
28592                 return 4;
28593               case 2: //vcc
28594                 return 8;
28595               default:
28596                 fatal("op idx %i out of bounds\n", opIdx);
28597                 return -1;
28598             }
28599         } // getOperandSize
28600
28601         bool
28602         isSrcOperand(int opIdx) override
28603         {
28604             switch (opIdx) {
28605               case 0: //src_0
28606                 return true;
28607               case 1: //src_1
28608                 return true;
28609               case 2: //vcc
28610                 return false;
28611               default:
28612                 fatal("op idx %i out of bounds\n", opIdx);
28613                 return false;
28614             }
28615         } // isSrcOperand
28616
28617         bool
28618         isDstOperand(int opIdx) override
28619         {
28620             switch (opIdx) {
28621               case 0: //src_0
28622                 return false;
28623               case 1: //src_1
28624                 return false;
28625               case 2: //vcc
28626                 return true;
28627               default:
28628                 fatal("op idx %i out of bounds\n", opIdx);
28629                 return false;
28630             }
28631         } // isDstOperand
28632
28633         void execute(GPUDynInstPtr) override;
28634     }; // Inst_VOPC__V_CMP_LT_U32
28635
28636     class Inst_VOPC__V_CMP_EQ_U32 : public Inst_VOPC
28637     {
28638       public:
28639         Inst_VOPC__V_CMP_EQ_U32(InFmt_VOPC*);
28640         ~Inst_VOPC__V_CMP_EQ_U32();
28641
28642         int
28643         getNumOperands() override
28644         {
28645             return numDstRegOperands() + numSrcRegOperands();
28646         } // getNumOperands
28647
28648         int numDstRegOperands() override { return 1; }
28649         int numSrcRegOperands() override { return 2; }
28650
28651         int
28652         getOperandSize(int opIdx) override
28653         {
28654             switch (opIdx) {
28655               case 0: //src_0
28656                 return 4;
28657               case 1: //src_1
28658                 return 4;
28659               case 2: //vcc
28660                 return 8;
28661               default:
28662                 fatal("op idx %i out of bounds\n", opIdx);
28663                 return -1;
28664             }
28665         } // getOperandSize
28666
28667         bool
28668         isSrcOperand(int opIdx) override
28669         {
28670             switch (opIdx) {
28671               case 0: //src_0
28672                 return true;
28673               case 1: //src_1
28674                 return true;
28675               case 2: //vcc
28676                 return false;
28677               default:
28678                 fatal("op idx %i out of bounds\n", opIdx);
28679                 return false;
28680             }
28681         } // isSrcOperand
28682
28683         bool
28684         isDstOperand(int opIdx) override
28685         {
28686             switch (opIdx) {
28687               case 0: //src_0
28688                 return false;
28689               case 1: //src_1
28690                 return false;
28691               case 2: //vcc
28692                 return true;
28693               default:
28694                 fatal("op idx %i out of bounds\n", opIdx);
28695                 return false;
28696             }
28697         } // isDstOperand
28698
28699         void execute(GPUDynInstPtr) override;
28700     }; // Inst_VOPC__V_CMP_EQ_U32
28701
28702     class Inst_VOPC__V_CMP_LE_U32 : public Inst_VOPC
28703     {
28704       public:
28705         Inst_VOPC__V_CMP_LE_U32(InFmt_VOPC*);
28706         ~Inst_VOPC__V_CMP_LE_U32();
28707
28708         int
28709         getNumOperands() override
28710         {
28711             return numDstRegOperands() + numSrcRegOperands();
28712         } // getNumOperands
28713
28714         int numDstRegOperands() override { return 1; }
28715         int numSrcRegOperands() override { return 2; }
28716
28717         int
28718         getOperandSize(int opIdx) override
28719         {
28720             switch (opIdx) {
28721               case 0: //src_0
28722                 return 4;
28723               case 1: //src_1
28724                 return 4;
28725               case 2: //vcc
28726                 return 8;
28727               default:
28728                 fatal("op idx %i out of bounds\n", opIdx);
28729                 return -1;
28730             }
28731         } // getOperandSize
28732
28733         bool
28734         isSrcOperand(int opIdx) override
28735         {
28736             switch (opIdx) {
28737               case 0: //src_0
28738                 return true;
28739               case 1: //src_1
28740                 return true;
28741               case 2: //vcc
28742                 return false;
28743               default:
28744                 fatal("op idx %i out of bounds\n", opIdx);
28745                 return false;
28746             }
28747         } // isSrcOperand
28748
28749         bool
28750         isDstOperand(int opIdx) override
28751         {
28752             switch (opIdx) {
28753               case 0: //src_0
28754                 return false;
28755               case 1: //src_1
28756                 return false;
28757               case 2: //vcc
28758                 return true;
28759               default:
28760                 fatal("op idx %i out of bounds\n", opIdx);
28761                 return false;
28762             }
28763         } // isDstOperand
28764
28765         void execute(GPUDynInstPtr) override;
28766     }; // Inst_VOPC__V_CMP_LE_U32
28767
28768     class Inst_VOPC__V_CMP_GT_U32 : public Inst_VOPC
28769     {
28770       public:
28771         Inst_VOPC__V_CMP_GT_U32(InFmt_VOPC*);
28772         ~Inst_VOPC__V_CMP_GT_U32();
28773
28774         int
28775         getNumOperands() override
28776         {
28777             return numDstRegOperands() + numSrcRegOperands();
28778         } // getNumOperands
28779
28780         int numDstRegOperands() override { return 1; }
28781         int numSrcRegOperands() override { return 2; }
28782
28783         int
28784         getOperandSize(int opIdx) override
28785         {
28786             switch (opIdx) {
28787               case 0: //src_0
28788                 return 4;
28789               case 1: //src_1
28790                 return 4;
28791               case 2: //vcc
28792                 return 8;
28793               default:
28794                 fatal("op idx %i out of bounds\n", opIdx);
28795                 return -1;
28796             }
28797         } // getOperandSize
28798
28799         bool
28800         isSrcOperand(int opIdx) override
28801         {
28802             switch (opIdx) {
28803               case 0: //src_0
28804                 return true;
28805               case 1: //src_1
28806                 return true;
28807               case 2: //vcc
28808                 return false;
28809               default:
28810                 fatal("op idx %i out of bounds\n", opIdx);
28811                 return false;
28812             }
28813         } // isSrcOperand
28814
28815         bool
28816         isDstOperand(int opIdx) override
28817         {
28818             switch (opIdx) {
28819               case 0: //src_0
28820                 return false;
28821               case 1: //src_1
28822                 return false;
28823               case 2: //vcc
28824                 return true;
28825               default:
28826                 fatal("op idx %i out of bounds\n", opIdx);
28827                 return false;
28828             }
28829         } // isDstOperand
28830
28831         void execute(GPUDynInstPtr) override;
28832     }; // Inst_VOPC__V_CMP_GT_U32
28833
28834     class Inst_VOPC__V_CMP_NE_U32 : public Inst_VOPC
28835     {
28836       public:
28837         Inst_VOPC__V_CMP_NE_U32(InFmt_VOPC*);
28838         ~Inst_VOPC__V_CMP_NE_U32();
28839
28840         int
28841         getNumOperands() override
28842         {
28843             return numDstRegOperands() + numSrcRegOperands();
28844         } // getNumOperands
28845
28846         int numDstRegOperands() override { return 1; }
28847         int numSrcRegOperands() override { return 2; }
28848
28849         int
28850         getOperandSize(int opIdx) override
28851         {
28852             switch (opIdx) {
28853               case 0: //src_0
28854                 return 4;
28855               case 1: //src_1
28856                 return 4;
28857               case 2: //vcc
28858                 return 8;
28859               default:
28860                 fatal("op idx %i out of bounds\n", opIdx);
28861                 return -1;
28862             }
28863         } // getOperandSize
28864
28865         bool
28866         isSrcOperand(int opIdx) override
28867         {
28868             switch (opIdx) {
28869               case 0: //src_0
28870                 return true;
28871               case 1: //src_1
28872                 return true;
28873               case 2: //vcc
28874                 return false;
28875               default:
28876                 fatal("op idx %i out of bounds\n", opIdx);
28877                 return false;
28878             }
28879         } // isSrcOperand
28880
28881         bool
28882         isDstOperand(int opIdx) override
28883         {
28884             switch (opIdx) {
28885               case 0: //src_0
28886                 return false;
28887               case 1: //src_1
28888                 return false;
28889               case 2: //vcc
28890                 return true;
28891               default:
28892                 fatal("op idx %i out of bounds\n", opIdx);
28893                 return false;
28894             }
28895         } // isDstOperand
28896
28897         void execute(GPUDynInstPtr) override;
28898     }; // Inst_VOPC__V_CMP_NE_U32
28899
28900     class Inst_VOPC__V_CMP_GE_U32 : public Inst_VOPC
28901     {
28902       public:
28903         Inst_VOPC__V_CMP_GE_U32(InFmt_VOPC*);
28904         ~Inst_VOPC__V_CMP_GE_U32();
28905
28906         int
28907         getNumOperands() override
28908         {
28909             return numDstRegOperands() + numSrcRegOperands();
28910         } // getNumOperands
28911
28912         int numDstRegOperands() override { return 1; }
28913         int numSrcRegOperands() override { return 2; }
28914
28915         int
28916         getOperandSize(int opIdx) override
28917         {
28918             switch (opIdx) {
28919               case 0: //src_0
28920                 return 4;
28921               case 1: //src_1
28922                 return 4;
28923               case 2: //vcc
28924                 return 8;
28925               default:
28926                 fatal("op idx %i out of bounds\n", opIdx);
28927                 return -1;
28928             }
28929         } // getOperandSize
28930
28931         bool
28932         isSrcOperand(int opIdx) override
28933         {
28934             switch (opIdx) {
28935               case 0: //src_0
28936                 return true;
28937               case 1: //src_1
28938                 return true;
28939               case 2: //vcc
28940                 return false;
28941               default:
28942                 fatal("op idx %i out of bounds\n", opIdx);
28943                 return false;
28944             }
28945         } // isSrcOperand
28946
28947         bool
28948         isDstOperand(int opIdx) override
28949         {
28950             switch (opIdx) {
28951               case 0: //src_0
28952                 return false;
28953               case 1: //src_1
28954                 return false;
28955               case 2: //vcc
28956                 return true;
28957               default:
28958                 fatal("op idx %i out of bounds\n", opIdx);
28959                 return false;
28960             }
28961         } // isDstOperand
28962
28963         void execute(GPUDynInstPtr) override;
28964     }; // Inst_VOPC__V_CMP_GE_U32
28965
28966     class Inst_VOPC__V_CMP_T_U32 : public Inst_VOPC
28967     {
28968       public:
28969         Inst_VOPC__V_CMP_T_U32(InFmt_VOPC*);
28970         ~Inst_VOPC__V_CMP_T_U32();
28971
28972         int
28973         getNumOperands() override
28974         {
28975             return numDstRegOperands() + numSrcRegOperands();
28976         } // getNumOperands
28977
28978         int numDstRegOperands() override { return 1; }
28979         int numSrcRegOperands() override { return 2; }
28980
28981         int
28982         getOperandSize(int opIdx) override
28983         {
28984             switch (opIdx) {
28985               case 0: //src_0
28986                 return 4;
28987               case 1: //src_1
28988                 return 4;
28989               case 2: //vcc
28990                 return 8;
28991               default:
28992                 fatal("op idx %i out of bounds\n", opIdx);
28993                 return -1;
28994             }
28995         } // getOperandSize
28996
28997         bool
28998         isSrcOperand(int opIdx) override
28999         {
29000             switch (opIdx) {
29001               case 0: //src_0
29002                 return true;
29003               case 1: //src_1
29004                 return true;
29005               case 2: //vcc
29006                 return false;
29007               default:
29008                 fatal("op idx %i out of bounds\n", opIdx);
29009                 return false;
29010             }
29011         } // isSrcOperand
29012
29013         bool
29014         isDstOperand(int opIdx) override
29015         {
29016             switch (opIdx) {
29017               case 0: //src_0
29018                 return false;
29019               case 1: //src_1
29020                 return false;
29021               case 2: //vcc
29022                 return true;
29023               default:
29024                 fatal("op idx %i out of bounds\n", opIdx);
29025                 return false;
29026             }
29027         } // isDstOperand
29028
29029         void execute(GPUDynInstPtr) override;
29030     }; // Inst_VOPC__V_CMP_T_U32
29031
29032     class Inst_VOPC__V_CMPX_F_I32 : public Inst_VOPC
29033     {
29034       public:
29035         Inst_VOPC__V_CMPX_F_I32(InFmt_VOPC*);
29036         ~Inst_VOPC__V_CMPX_F_I32();
29037
29038         int
29039         getNumOperands() override
29040         {
29041             return numDstRegOperands() + numSrcRegOperands();
29042         } // getNumOperands
29043
29044         int numDstRegOperands() override { return 1; }
29045         int numSrcRegOperands() override { return 2; }
29046
29047         int
29048         getOperandSize(int opIdx) override
29049         {
29050             switch (opIdx) {
29051               case 0: //src_0
29052                 return 4;
29053               case 1: //src_1
29054                 return 4;
29055               case 2: //vcc
29056                 return 8;
29057               default:
29058                 fatal("op idx %i out of bounds\n", opIdx);
29059                 return -1;
29060             }
29061         } // getOperandSize
29062
29063         bool
29064         isSrcOperand(int opIdx) override
29065         {
29066             switch (opIdx) {
29067               case 0: //src_0
29068                 return true;
29069               case 1: //src_1
29070                 return true;
29071               default:
29072                 fatal("op idx %i out of bounds\n", opIdx);
29073                 return false;
29074             }
29075         } // isSrcOperand
29076
29077         bool
29078         isDstOperand(int opIdx) override
29079         {
29080             switch (opIdx) {
29081               case 0: //src_0
29082                 return false;
29083               case 1: //src_1
29084                 return false;
29085               default:
29086                 fatal("op idx %i out of bounds\n", opIdx);
29087                 return false;
29088             }
29089         } // isDstOperand
29090
29091         void execute(GPUDynInstPtr) override;
29092     }; // Inst_VOPC__V_CMPX_F_I32
29093
29094     class Inst_VOPC__V_CMPX_LT_I32 : public Inst_VOPC
29095     {
29096       public:
29097         Inst_VOPC__V_CMPX_LT_I32(InFmt_VOPC*);
29098         ~Inst_VOPC__V_CMPX_LT_I32();
29099
29100         int
29101         getNumOperands() override
29102         {
29103             return numDstRegOperands() + numSrcRegOperands();
29104         } // getNumOperands
29105
29106         int numDstRegOperands() override { return 1; }
29107         int numSrcRegOperands() override { return 2; }
29108
29109         int
29110         getOperandSize(int opIdx) override
29111         {
29112             switch (opIdx) {
29113               case 0: //src_0
29114                 return 4;
29115               case 1: //src_1
29116                 return 4;
29117               case 2: //vcc
29118                 return 8;
29119               default:
29120                 fatal("op idx %i out of bounds\n", opIdx);
29121                 return -1;
29122             }
29123         } // getOperandSize
29124
29125         bool
29126         isSrcOperand(int opIdx) override
29127         {
29128             switch (opIdx) {
29129               case 0: //src_0
29130                 return true;
29131               case 1: //src_1
29132                 return true;
29133               default:
29134                 fatal("op idx %i out of bounds\n", opIdx);
29135                 return false;
29136             }
29137         } // isSrcOperand
29138
29139         bool
29140         isDstOperand(int opIdx) override
29141         {
29142             switch (opIdx) {
29143               case 0: //src_0
29144                 return false;
29145               case 1: //src_1
29146                 return false;
29147               default:
29148                 fatal("op idx %i out of bounds\n", opIdx);
29149                 return false;
29150             }
29151         } // isDstOperand
29152
29153         void execute(GPUDynInstPtr) override;
29154     }; // Inst_VOPC__V_CMPX_LT_I32
29155
29156     class Inst_VOPC__V_CMPX_EQ_I32 : public Inst_VOPC
29157     {
29158       public:
29159         Inst_VOPC__V_CMPX_EQ_I32(InFmt_VOPC*);
29160         ~Inst_VOPC__V_CMPX_EQ_I32();
29161
29162         int
29163         getNumOperands() override
29164         {
29165             return numDstRegOperands() + numSrcRegOperands();
29166         } // getNumOperands
29167
29168         int numDstRegOperands() override { return 1; }
29169         int numSrcRegOperands() override { return 2; }
29170
29171         int
29172         getOperandSize(int opIdx) override
29173         {
29174             switch (opIdx) {
29175               case 0: //src_0
29176                 return 4;
29177               case 1: //src_1
29178                 return 4;
29179               case 2: //vcc
29180                 return 8;
29181               default:
29182                 fatal("op idx %i out of bounds\n", opIdx);
29183                 return -1;
29184             }
29185         } // getOperandSize
29186
29187         bool
29188         isSrcOperand(int opIdx) override
29189         {
29190             switch (opIdx) {
29191               case 0: //src_0
29192                 return true;
29193               case 1: //src_1
29194                 return true;
29195               default:
29196                 fatal("op idx %i out of bounds\n", opIdx);
29197                 return false;
29198             }
29199         } // isSrcOperand
29200
29201         bool
29202         isDstOperand(int opIdx) override
29203         {
29204             switch (opIdx) {
29205               case 0: //src_0
29206                 return false;
29207               case 1: //src_1
29208                 return false;
29209               default:
29210                 fatal("op idx %i out of bounds\n", opIdx);
29211                 return false;
29212             }
29213         } // isDstOperand
29214
29215         void execute(GPUDynInstPtr) override;
29216     }; // Inst_VOPC__V_CMPX_EQ_I32
29217
29218     class Inst_VOPC__V_CMPX_LE_I32 : public Inst_VOPC
29219     {
29220       public:
29221         Inst_VOPC__V_CMPX_LE_I32(InFmt_VOPC*);
29222         ~Inst_VOPC__V_CMPX_LE_I32();
29223
29224         int
29225         getNumOperands() override
29226         {
29227             return numDstRegOperands() + numSrcRegOperands();
29228         } // getNumOperands
29229
29230         int numDstRegOperands() override { return 1; }
29231         int numSrcRegOperands() override { return 2; }
29232
29233         int
29234         getOperandSize(int opIdx) override
29235         {
29236             switch (opIdx) {
29237               case 0: //src_0
29238                 return 4;
29239               case 1: //src_1
29240                 return 4;
29241               case 2: //vcc
29242                 return 8;
29243               default:
29244                 fatal("op idx %i out of bounds\n", opIdx);
29245                 return -1;
29246             }
29247         } // getOperandSize
29248
29249         bool
29250         isSrcOperand(int opIdx) override
29251         {
29252             switch (opIdx) {
29253               case 0: //src_0
29254                 return true;
29255               case 1: //src_1
29256                 return true;
29257               default:
29258                 fatal("op idx %i out of bounds\n", opIdx);
29259                 return false;
29260             }
29261         } // isSrcOperand
29262
29263         bool
29264         isDstOperand(int opIdx) override
29265         {
29266             switch (opIdx) {
29267               case 0: //src_0
29268                 return false;
29269               case 1: //src_1
29270                 return false;
29271               default:
29272                 fatal("op idx %i out of bounds\n", opIdx);
29273                 return false;
29274             }
29275         } // isDstOperand
29276
29277         void execute(GPUDynInstPtr) override;
29278     }; // Inst_VOPC__V_CMPX_LE_I32
29279
29280     class Inst_VOPC__V_CMPX_GT_I32 : public Inst_VOPC
29281     {
29282       public:
29283         Inst_VOPC__V_CMPX_GT_I32(InFmt_VOPC*);
29284         ~Inst_VOPC__V_CMPX_GT_I32();
29285
29286         int
29287         getNumOperands() override
29288         {
29289             return numDstRegOperands() + numSrcRegOperands();
29290         } // getNumOperands
29291
29292         int numDstRegOperands() override { return 1; }
29293         int numSrcRegOperands() override { return 2; }
29294
29295         int
29296         getOperandSize(int opIdx) override
29297         {
29298             switch (opIdx) {
29299               case 0: //src_0
29300                 return 4;
29301               case 1: //src_1
29302                 return 4;
29303               case 2: //vcc
29304                 return 8;
29305               default:
29306                 fatal("op idx %i out of bounds\n", opIdx);
29307                 return -1;
29308             }
29309         } // getOperandSize
29310
29311         bool
29312         isSrcOperand(int opIdx) override
29313         {
29314             switch (opIdx) {
29315               case 0: //src_0
29316                 return true;
29317               case 1: //src_1
29318                 return true;
29319               default:
29320                 fatal("op idx %i out of bounds\n", opIdx);
29321                 return false;
29322             }
29323         } // isSrcOperand
29324
29325         bool
29326         isDstOperand(int opIdx) override
29327         {
29328             switch (opIdx) {
29329               case 0: //src_0
29330                 return false;
29331               case 1: //src_1
29332                 return false;
29333               default:
29334                 fatal("op idx %i out of bounds\n", opIdx);
29335                 return false;
29336             }
29337         } // isDstOperand
29338
29339         void execute(GPUDynInstPtr) override;
29340     }; // Inst_VOPC__V_CMPX_GT_I32
29341
29342     class Inst_VOPC__V_CMPX_NE_I32 : public Inst_VOPC
29343     {
29344       public:
29345         Inst_VOPC__V_CMPX_NE_I32(InFmt_VOPC*);
29346         ~Inst_VOPC__V_CMPX_NE_I32();
29347
29348         int
29349         getNumOperands() override
29350         {
29351             return numDstRegOperands() + numSrcRegOperands();
29352         } // getNumOperands
29353
29354         int numDstRegOperands() override { return 1; }
29355         int numSrcRegOperands() override { return 2; }
29356
29357         int
29358         getOperandSize(int opIdx) override
29359         {
29360             switch (opIdx) {
29361               case 0: //src_0
29362                 return 4;
29363               case 1: //src_1
29364                 return 4;
29365               case 2: //vcc
29366                 return 8;
29367               default:
29368                 fatal("op idx %i out of bounds\n", opIdx);
29369                 return -1;
29370             }
29371         } // getOperandSize
29372
29373         bool
29374         isSrcOperand(int opIdx) override
29375         {
29376             switch (opIdx) {
29377               case 0: //src_0
29378                 return true;
29379               case 1: //src_1
29380                 return true;
29381               default:
29382                 fatal("op idx %i out of bounds\n", opIdx);
29383                 return false;
29384             }
29385         } // isSrcOperand
29386
29387         bool
29388         isDstOperand(int opIdx) override
29389         {
29390             switch (opIdx) {
29391               case 0: //src_0
29392                 return false;
29393               case 1: //src_1
29394                 return false;
29395               default:
29396                 fatal("op idx %i out of bounds\n", opIdx);
29397                 return false;
29398             }
29399         } // isDstOperand
29400
29401         void execute(GPUDynInstPtr) override;
29402     }; // Inst_VOPC__V_CMPX_NE_I32
29403
29404     class Inst_VOPC__V_CMPX_GE_I32 : public Inst_VOPC
29405     {
29406       public:
29407         Inst_VOPC__V_CMPX_GE_I32(InFmt_VOPC*);
29408         ~Inst_VOPC__V_CMPX_GE_I32();
29409
29410         int
29411         getNumOperands() override
29412         {
29413             return numDstRegOperands() + numSrcRegOperands();
29414         } // getNumOperands
29415
29416         int numDstRegOperands() override { return 1; }
29417         int numSrcRegOperands() override { return 2; }
29418
29419         int
29420         getOperandSize(int opIdx) override
29421         {
29422             switch (opIdx) {
29423               case 0: //src_0
29424                 return 4;
29425               case 1: //src_1
29426                 return 4;
29427               case 2: //vcc
29428                 return 8;
29429               default:
29430                 fatal("op idx %i out of bounds\n", opIdx);
29431                 return -1;
29432             }
29433         } // getOperandSize
29434
29435         bool
29436         isSrcOperand(int opIdx) override
29437         {
29438             switch (opIdx) {
29439               case 0: //src_0
29440                 return true;
29441               case 1: //src_1
29442                 return true;
29443               default:
29444                 fatal("op idx %i out of bounds\n", opIdx);
29445                 return false;
29446             }
29447         } // isSrcOperand
29448
29449         bool
29450         isDstOperand(int opIdx) override
29451         {
29452             switch (opIdx) {
29453               case 0: //src_0
29454                 return false;
29455               case 1: //src_1
29456                 return false;
29457               default:
29458                 fatal("op idx %i out of bounds\n", opIdx);
29459                 return false;
29460             }
29461         } // isDstOperand
29462
29463         void execute(GPUDynInstPtr) override;
29464     }; // Inst_VOPC__V_CMPX_GE_I32
29465
29466     class Inst_VOPC__V_CMPX_T_I32 : public Inst_VOPC
29467     {
29468       public:
29469         Inst_VOPC__V_CMPX_T_I32(InFmt_VOPC*);
29470         ~Inst_VOPC__V_CMPX_T_I32();
29471
29472         int
29473         getNumOperands() override
29474         {
29475             return numDstRegOperands() + numSrcRegOperands();
29476         } // getNumOperands
29477
29478         int numDstRegOperands() override { return 1; }
29479         int numSrcRegOperands() override { return 2; }
29480
29481         int
29482         getOperandSize(int opIdx) override
29483         {
29484             switch (opIdx) {
29485               case 0: //src_0
29486                 return 4;
29487               case 1: //src_1
29488                 return 4;
29489               case 2: //vcc
29490                 return 8;
29491               default:
29492                 fatal("op idx %i out of bounds\n", opIdx);
29493                 return -1;
29494             }
29495         } // getOperandSize
29496
29497         bool
29498         isSrcOperand(int opIdx) override
29499         {
29500             switch (opIdx) {
29501               case 0: //src_0
29502                 return true;
29503               case 1: //src_1
29504                 return true;
29505               default:
29506                 fatal("op idx %i out of bounds\n", opIdx);
29507                 return false;
29508             }
29509         } // isSrcOperand
29510
29511         bool
29512         isDstOperand(int opIdx) override
29513         {
29514             switch (opIdx) {
29515               case 0: //src_0
29516                 return false;
29517               case 1: //src_1
29518                 return false;
29519               default:
29520                 fatal("op idx %i out of bounds\n", opIdx);
29521                 return false;
29522             }
29523         } // isDstOperand
29524
29525         void execute(GPUDynInstPtr) override;
29526     }; // Inst_VOPC__V_CMPX_T_I32
29527
29528     class Inst_VOPC__V_CMPX_F_U32 : public Inst_VOPC
29529     {
29530       public:
29531         Inst_VOPC__V_CMPX_F_U32(InFmt_VOPC*);
29532         ~Inst_VOPC__V_CMPX_F_U32();
29533
29534         int
29535         getNumOperands() override
29536         {
29537             return numDstRegOperands() + numSrcRegOperands();
29538         } // getNumOperands
29539
29540         int numDstRegOperands() override { return 1; }
29541         int numSrcRegOperands() override { return 2; }
29542
29543         int
29544         getOperandSize(int opIdx) override
29545         {
29546             switch (opIdx) {
29547               case 0: //src_0
29548                 return 4;
29549               case 1: //src_1
29550                 return 4;
29551               case 2: //vcc
29552                 return 8;
29553               default:
29554                 fatal("op idx %i out of bounds\n", opIdx);
29555                 return -1;
29556             }
29557         } // getOperandSize
29558
29559         bool
29560         isSrcOperand(int opIdx) override
29561         {
29562             switch (opIdx) {
29563               case 0: //src_0
29564                 return true;
29565               case 1: //src_1
29566                 return true;
29567               default:
29568                 fatal("op idx %i out of bounds\n", opIdx);
29569                 return false;
29570             }
29571         } // isSrcOperand
29572
29573         bool
29574         isDstOperand(int opIdx) override
29575         {
29576             switch (opIdx) {
29577               case 0: //src_0
29578                 return false;
29579               case 1: //src_1
29580                 return false;
29581               default:
29582                 fatal("op idx %i out of bounds\n", opIdx);
29583                 return false;
29584             }
29585         } // isDstOperand
29586
29587         void execute(GPUDynInstPtr) override;
29588     }; // Inst_VOPC__V_CMPX_F_U32
29589
29590     class Inst_VOPC__V_CMPX_LT_U32 : public Inst_VOPC
29591     {
29592       public:
29593         Inst_VOPC__V_CMPX_LT_U32(InFmt_VOPC*);
29594         ~Inst_VOPC__V_CMPX_LT_U32();
29595
29596         int
29597         getNumOperands() override
29598         {
29599             return numDstRegOperands() + numSrcRegOperands();
29600         } // getNumOperands
29601
29602         int numDstRegOperands() override { return 1; }
29603         int numSrcRegOperands() override { return 2; }
29604
29605         int
29606         getOperandSize(int opIdx) override
29607         {
29608             switch (opIdx) {
29609               case 0: //src_0
29610                 return 4;
29611               case 1: //src_1
29612                 return 4;
29613               case 2: //vcc
29614                 return 8;
29615               default:
29616                 fatal("op idx %i out of bounds\n", opIdx);
29617                 return -1;
29618             }
29619         } // getOperandSize
29620
29621         bool
29622         isSrcOperand(int opIdx) override
29623         {
29624             switch (opIdx) {
29625               case 0: //src_0
29626                 return true;
29627               case 1: //src_1
29628                 return true;
29629               default:
29630                 fatal("op idx %i out of bounds\n", opIdx);
29631                 return false;
29632             }
29633         } // isSrcOperand
29634
29635         bool
29636         isDstOperand(int opIdx) override
29637         {
29638             switch (opIdx) {
29639               case 0: //src_0
29640                 return false;
29641               case 1: //src_1
29642                 return false;
29643               default:
29644                 fatal("op idx %i out of bounds\n", opIdx);
29645                 return false;
29646             }
29647         } // isDstOperand
29648
29649         void execute(GPUDynInstPtr) override;
29650     }; // Inst_VOPC__V_CMPX_LT_U32
29651
29652     class Inst_VOPC__V_CMPX_EQ_U32 : public Inst_VOPC
29653     {
29654       public:
29655         Inst_VOPC__V_CMPX_EQ_U32(InFmt_VOPC*);
29656         ~Inst_VOPC__V_CMPX_EQ_U32();
29657
29658         int
29659         getNumOperands() override
29660         {
29661             return numDstRegOperands() + numSrcRegOperands();
29662         } // getNumOperands
29663
29664         int numDstRegOperands() override { return 1; }
29665         int numSrcRegOperands() override { return 2; }
29666
29667         int
29668         getOperandSize(int opIdx) override
29669         {
29670             switch (opIdx) {
29671               case 0: //src_0
29672                 return 4;
29673               case 1: //src_1
29674                 return 4;
29675               case 2: //vcc
29676                 return 8;
29677               default:
29678                 fatal("op idx %i out of bounds\n", opIdx);
29679                 return -1;
29680             }
29681         } // getOperandSize
29682
29683         bool
29684         isSrcOperand(int opIdx) override
29685         {
29686             switch (opIdx) {
29687               case 0: //src_0
29688                 return true;
29689               case 1: //src_1
29690                 return true;
29691               default:
29692                 fatal("op idx %i out of bounds\n", opIdx);
29693                 return false;
29694             }
29695         } // isSrcOperand
29696
29697         bool
29698         isDstOperand(int opIdx) override
29699         {
29700             switch (opIdx) {
29701               case 0: //src_0
29702                 return false;
29703               case 1: //src_1
29704                 return false;
29705               default:
29706                 fatal("op idx %i out of bounds\n", opIdx);
29707                 return false;
29708             }
29709         } // isDstOperand
29710
29711         void execute(GPUDynInstPtr) override;
29712     }; // Inst_VOPC__V_CMPX_EQ_U32
29713
29714     class Inst_VOPC__V_CMPX_LE_U32 : public Inst_VOPC
29715     {
29716       public:
29717         Inst_VOPC__V_CMPX_LE_U32(InFmt_VOPC*);
29718         ~Inst_VOPC__V_CMPX_LE_U32();
29719
29720         int
29721         getNumOperands() override
29722         {
29723             return numDstRegOperands() + numSrcRegOperands();
29724         } // getNumOperands
29725
29726         int numDstRegOperands() override { return 1; }
29727         int numSrcRegOperands() override { return 2; }
29728
29729         int
29730         getOperandSize(int opIdx) override
29731         {
29732             switch (opIdx) {
29733               case 0: //src_0
29734                 return 4;
29735               case 1: //src_1
29736                 return 4;
29737               case 2: //vcc
29738                 return 8;
29739               default:
29740                 fatal("op idx %i out of bounds\n", opIdx);
29741                 return -1;
29742             }
29743         } // getOperandSize
29744
29745         bool
29746         isSrcOperand(int opIdx) override
29747         {
29748             switch (opIdx) {
29749               case 0: //src_0
29750                 return true;
29751               case 1: //src_1
29752                 return true;
29753               default:
29754                 fatal("op idx %i out of bounds\n", opIdx);
29755                 return false;
29756             }
29757         } // isSrcOperand
29758
29759         bool
29760         isDstOperand(int opIdx) override
29761         {
29762             switch (opIdx) {
29763               case 0: //src_0
29764                 return false;
29765               case 1: //src_1
29766                 return false;
29767               default:
29768                 fatal("op idx %i out of bounds\n", opIdx);
29769                 return false;
29770             }
29771         } // isDstOperand
29772
29773         void execute(GPUDynInstPtr) override;
29774     }; // Inst_VOPC__V_CMPX_LE_U32
29775
29776     class Inst_VOPC__V_CMPX_GT_U32 : public Inst_VOPC
29777     {
29778       public:
29779         Inst_VOPC__V_CMPX_GT_U32(InFmt_VOPC*);
29780         ~Inst_VOPC__V_CMPX_GT_U32();
29781
29782         int
29783         getNumOperands() override
29784         {
29785             return numDstRegOperands() + numSrcRegOperands();
29786         } // getNumOperands
29787
29788         int numDstRegOperands() override { return 1; }
29789         int numSrcRegOperands() override { return 2; }
29790
29791         int
29792         getOperandSize(int opIdx) override
29793         {
29794             switch (opIdx) {
29795               case 0: //src_0
29796                 return 4;
29797               case 1: //src_1
29798                 return 4;
29799               case 2: //vcc
29800                 return 8;
29801               default:
29802                 fatal("op idx %i out of bounds\n", opIdx);
29803                 return -1;
29804             }
29805         } // getOperandSize
29806
29807         bool
29808         isSrcOperand(int opIdx) override
29809         {
29810             switch (opIdx) {
29811               case 0: //src_0
29812                 return true;
29813               case 1: //src_1
29814                 return true;
29815               default:
29816                 fatal("op idx %i out of bounds\n", opIdx);
29817                 return false;
29818             }
29819         } // isSrcOperand
29820
29821         bool
29822         isDstOperand(int opIdx) override
29823         {
29824             switch (opIdx) {
29825               case 0: //src_0
29826                 return false;
29827               case 1: //src_1
29828                 return false;
29829               default:
29830                 fatal("op idx %i out of bounds\n", opIdx);
29831                 return false;
29832             }
29833         } // isDstOperand
29834
29835         void execute(GPUDynInstPtr) override;
29836     }; // Inst_VOPC__V_CMPX_GT_U32
29837
29838     class Inst_VOPC__V_CMPX_NE_U32 : public Inst_VOPC
29839     {
29840       public:
29841         Inst_VOPC__V_CMPX_NE_U32(InFmt_VOPC*);
29842         ~Inst_VOPC__V_CMPX_NE_U32();
29843
29844         int
29845         getNumOperands() override
29846         {
29847             return numDstRegOperands() + numSrcRegOperands();
29848         } // getNumOperands
29849
29850         int numDstRegOperands() override { return 1; }
29851         int numSrcRegOperands() override { return 2; }
29852
29853         int
29854         getOperandSize(int opIdx) override
29855         {
29856             switch (opIdx) {
29857               case 0: //src_0
29858                 return 4;
29859               case 1: //src_1
29860                 return 4;
29861               case 2: //vcc
29862                 return 8;
29863               default:
29864                 fatal("op idx %i out of bounds\n", opIdx);
29865                 return -1;
29866             }
29867         } // getOperandSize
29868
29869         bool
29870         isSrcOperand(int opIdx) override
29871         {
29872             switch (opIdx) {
29873               case 0: //src_0
29874                 return true;
29875               case 1: //src_1
29876                 return true;
29877               default:
29878                 fatal("op idx %i out of bounds\n", opIdx);
29879                 return false;
29880             }
29881         } // isSrcOperand
29882
29883         bool
29884         isDstOperand(int opIdx) override
29885         {
29886             switch (opIdx) {
29887               case 0: //src_0
29888                 return false;
29889               case 1: //src_1
29890                 return false;
29891               default:
29892                 fatal("op idx %i out of bounds\n", opIdx);
29893                 return false;
29894             }
29895         } // isDstOperand
29896
29897         void execute(GPUDynInstPtr) override;
29898     }; // Inst_VOPC__V_CMPX_NE_U32
29899
29900     class Inst_VOPC__V_CMPX_GE_U32 : public Inst_VOPC
29901     {
29902       public:
29903         Inst_VOPC__V_CMPX_GE_U32(InFmt_VOPC*);
29904         ~Inst_VOPC__V_CMPX_GE_U32();
29905
29906         int
29907         getNumOperands() override
29908         {
29909             return numDstRegOperands() + numSrcRegOperands();
29910         } // getNumOperands
29911
29912         int numDstRegOperands() override { return 1; }
29913         int numSrcRegOperands() override { return 2; }
29914
29915         int
29916         getOperandSize(int opIdx) override
29917         {
29918             switch (opIdx) {
29919               case 0: //src_0
29920                 return 4;
29921               case 1: //src_1
29922                 return 4;
29923               case 2: //vcc
29924                 return 8;
29925               default:
29926                 fatal("op idx %i out of bounds\n", opIdx);
29927                 return -1;
29928             }
29929         } // getOperandSize
29930
29931         bool
29932         isSrcOperand(int opIdx) override
29933         {
29934             switch (opIdx) {
29935               case 0: //src_0
29936                 return true;
29937               case 1: //src_1
29938                 return true;
29939               default:
29940                 fatal("op idx %i out of bounds\n", opIdx);
29941                 return false;
29942             }
29943         } // isSrcOperand
29944
29945         bool
29946         isDstOperand(int opIdx) override
29947         {
29948             switch (opIdx) {
29949               case 0: //src_0
29950                 return false;
29951               case 1: //src_1
29952                 return false;
29953               default:
29954                 fatal("op idx %i out of bounds\n", opIdx);
29955                 return false;
29956             }
29957         } // isDstOperand
29958
29959         void execute(GPUDynInstPtr) override;
29960     }; // Inst_VOPC__V_CMPX_GE_U32
29961
29962     class Inst_VOPC__V_CMPX_T_U32 : public Inst_VOPC
29963     {
29964       public:
29965         Inst_VOPC__V_CMPX_T_U32(InFmt_VOPC*);
29966         ~Inst_VOPC__V_CMPX_T_U32();
29967
29968         int
29969         getNumOperands() override
29970         {
29971             return numDstRegOperands() + numSrcRegOperands();
29972         } // getNumOperands
29973
29974         int numDstRegOperands() override { return 1; }
29975         int numSrcRegOperands() override { return 2; }
29976
29977         int
29978         getOperandSize(int opIdx) override
29979         {
29980             switch (opIdx) {
29981               case 0: //src_0
29982                 return 4;
29983               case 1: //src_1
29984                 return 4;
29985               case 2: //vcc
29986                 return 8;
29987               default:
29988                 fatal("op idx %i out of bounds\n", opIdx);
29989                 return -1;
29990             }
29991         } // getOperandSize
29992
29993         bool
29994         isSrcOperand(int opIdx) override
29995         {
29996             switch (opIdx) {
29997               case 0: //src_0
29998                 return true;
29999               case 1: //src_1
30000                 return true;
30001               default:
30002                 fatal("op idx %i out of bounds\n", opIdx);
30003                 return false;
30004             }
30005         } // isSrcOperand
30006
30007         bool
30008         isDstOperand(int opIdx) override
30009         {
30010             switch (opIdx) {
30011               case 0: //src_0
30012                 return false;
30013               case 1: //src_1
30014                 return false;
30015               default:
30016                 fatal("op idx %i out of bounds\n", opIdx);
30017                 return false;
30018             }
30019         } // isDstOperand
30020
30021         void execute(GPUDynInstPtr) override;
30022     }; // Inst_VOPC__V_CMPX_T_U32
30023
30024     class Inst_VOPC__V_CMP_F_I64 : public Inst_VOPC
30025     {
30026       public:
30027         Inst_VOPC__V_CMP_F_I64(InFmt_VOPC*);
30028         ~Inst_VOPC__V_CMP_F_I64();
30029
30030         int
30031         getNumOperands() override
30032         {
30033             return numDstRegOperands() + numSrcRegOperands();
30034         } // getNumOperands
30035
30036         int numDstRegOperands() override { return 1; }
30037         int numSrcRegOperands() override { return 2; }
30038
30039         int
30040         getOperandSize(int opIdx) override
30041         {
30042             switch (opIdx) {
30043               case 0: //src_0
30044                 return 8;
30045               case 1: //src_1
30046                 return 8;
30047               case 2: //vcc
30048                 return 8;
30049               default:
30050                 fatal("op idx %i out of bounds\n", opIdx);
30051                 return -1;
30052             }
30053         } // getOperandSize
30054
30055         bool
30056         isSrcOperand(int opIdx) override
30057         {
30058             switch (opIdx) {
30059               case 0: //src_0
30060                 return true;
30061               case 1: //src_1
30062                 return true;
30063               case 2: //vcc
30064                 return false;
30065               default:
30066                 fatal("op idx %i out of bounds\n", opIdx);
30067                 return false;
30068             }
30069         } // isSrcOperand
30070
30071         bool
30072         isDstOperand(int opIdx) override
30073         {
30074             switch (opIdx) {
30075               case 0: //src_0
30076                 return false;
30077               case 1: //src_1
30078                 return false;
30079               case 2: //vcc
30080                 return true;
30081               default:
30082                 fatal("op idx %i out of bounds\n", opIdx);
30083                 return false;
30084             }
30085         } // isDstOperand
30086
30087         void execute(GPUDynInstPtr) override;
30088     }; // Inst_VOPC__V_CMP_F_I64
30089
30090     class Inst_VOPC__V_CMP_LT_I64 : public Inst_VOPC
30091     {
30092       public:
30093         Inst_VOPC__V_CMP_LT_I64(InFmt_VOPC*);
30094         ~Inst_VOPC__V_CMP_LT_I64();
30095
30096         int
30097         getNumOperands() override
30098         {
30099             return numDstRegOperands() + numSrcRegOperands();
30100         } // getNumOperands
30101
30102         int numDstRegOperands() override { return 1; }
30103         int numSrcRegOperands() override { return 2; }
30104
30105         int
30106         getOperandSize(int opIdx) override
30107         {
30108             switch (opIdx) {
30109               case 0: //src_0
30110                 return 8;
30111               case 1: //src_1
30112                 return 8;
30113               case 2: //vcc
30114                 return 8;
30115               default:
30116                 fatal("op idx %i out of bounds\n", opIdx);
30117                 return -1;
30118             }
30119         } // getOperandSize
30120
30121         bool
30122         isSrcOperand(int opIdx) override
30123         {
30124             switch (opIdx) {
30125               case 0: //src_0
30126                 return true;
30127               case 1: //src_1
30128                 return true;
30129               case 2: //vcc
30130                 return false;
30131               default:
30132                 fatal("op idx %i out of bounds\n", opIdx);
30133                 return false;
30134             }
30135         } // isSrcOperand
30136
30137         bool
30138         isDstOperand(int opIdx) override
30139         {
30140             switch (opIdx) {
30141               case 0: //src_0
30142                 return false;
30143               case 1: //src_1
30144                 return false;
30145               case 2: //vcc
30146                 return true;
30147               default:
30148                 fatal("op idx %i out of bounds\n", opIdx);
30149                 return false;
30150             }
30151         } // isDstOperand
30152
30153         void execute(GPUDynInstPtr) override;
30154     }; // Inst_VOPC__V_CMP_LT_I64
30155
30156     class Inst_VOPC__V_CMP_EQ_I64 : public Inst_VOPC
30157     {
30158       public:
30159         Inst_VOPC__V_CMP_EQ_I64(InFmt_VOPC*);
30160         ~Inst_VOPC__V_CMP_EQ_I64();
30161
30162         int
30163         getNumOperands() override
30164         {
30165             return numDstRegOperands() + numSrcRegOperands();
30166         } // getNumOperands
30167
30168         int numDstRegOperands() override { return 1; }
30169         int numSrcRegOperands() override { return 2; }
30170
30171         int
30172         getOperandSize(int opIdx) override
30173         {
30174             switch (opIdx) {
30175               case 0: //src_0
30176                 return 8;
30177               case 1: //src_1
30178                 return 8;
30179               case 2: //vcc
30180                 return 8;
30181               default:
30182                 fatal("op idx %i out of bounds\n", opIdx);
30183                 return -1;
30184             }
30185         } // getOperandSize
30186
30187         bool
30188         isSrcOperand(int opIdx) override
30189         {
30190             switch (opIdx) {
30191               case 0: //src_0
30192                 return true;
30193               case 1: //src_1
30194                 return true;
30195               case 2: //vcc
30196                 return false;
30197               default:
30198                 fatal("op idx %i out of bounds\n", opIdx);
30199                 return false;
30200             }
30201         } // isSrcOperand
30202
30203         bool
30204         isDstOperand(int opIdx) override
30205         {
30206             switch (opIdx) {
30207               case 0: //src_0
30208                 return false;
30209               case 1: //src_1
30210                 return false;
30211               case 2: //vcc
30212                 return true;
30213               default:
30214                 fatal("op idx %i out of bounds\n", opIdx);
30215                 return false;
30216             }
30217         } // isDstOperand
30218
30219         void execute(GPUDynInstPtr) override;
30220     }; // Inst_VOPC__V_CMP_EQ_I64
30221
30222     class Inst_VOPC__V_CMP_LE_I64 : public Inst_VOPC
30223     {
30224       public:
30225         Inst_VOPC__V_CMP_LE_I64(InFmt_VOPC*);
30226         ~Inst_VOPC__V_CMP_LE_I64();
30227
30228         int
30229         getNumOperands() override
30230         {
30231             return numDstRegOperands() + numSrcRegOperands();
30232         } // getNumOperands
30233
30234         int numDstRegOperands() override { return 1; }
30235         int numSrcRegOperands() override { return 2; }
30236
30237         int
30238         getOperandSize(int opIdx) override
30239         {
30240             switch (opIdx) {
30241               case 0: //src_0
30242                 return 8;
30243               case 1: //src_1
30244                 return 8;
30245               case 2: //vcc
30246                 return 8;
30247               default:
30248                 fatal("op idx %i out of bounds\n", opIdx);
30249                 return -1;
30250             }
30251         } // getOperandSize
30252
30253         bool
30254         isSrcOperand(int opIdx) override
30255         {
30256             switch (opIdx) {
30257               case 0: //src_0
30258                 return true;
30259               case 1: //src_1
30260                 return true;
30261               case 2: //vcc
30262                 return false;
30263               default:
30264                 fatal("op idx %i out of bounds\n", opIdx);
30265                 return false;
30266             }
30267         } // isSrcOperand
30268
30269         bool
30270         isDstOperand(int opIdx) override
30271         {
30272             switch (opIdx) {
30273               case 0: //src_0
30274                 return false;
30275               case 1: //src_1
30276                 return false;
30277               case 2: //vcc
30278                 return true;
30279               default:
30280                 fatal("op idx %i out of bounds\n", opIdx);
30281                 return false;
30282             }
30283         } // isDstOperand
30284
30285         void execute(GPUDynInstPtr) override;
30286     }; // Inst_VOPC__V_CMP_LE_I64
30287
30288     class Inst_VOPC__V_CMP_GT_I64 : public Inst_VOPC
30289     {
30290       public:
30291         Inst_VOPC__V_CMP_GT_I64(InFmt_VOPC*);
30292         ~Inst_VOPC__V_CMP_GT_I64();
30293
30294         int
30295         getNumOperands() override
30296         {
30297             return numDstRegOperands() + numSrcRegOperands();
30298         } // getNumOperands
30299
30300         int numDstRegOperands() override { return 1; }
30301         int numSrcRegOperands() override { return 2; }
30302
30303         int
30304         getOperandSize(int opIdx) override
30305         {
30306             switch (opIdx) {
30307               case 0: //src_0
30308                 return 8;
30309               case 1: //src_1
30310                 return 8;
30311               case 2: //vcc
30312                 return 8;
30313               default:
30314                 fatal("op idx %i out of bounds\n", opIdx);
30315                 return -1;
30316             }
30317         } // getOperandSize
30318
30319         bool
30320         isSrcOperand(int opIdx) override
30321         {
30322             switch (opIdx) {
30323               case 0: //src_0
30324                 return true;
30325               case 1: //src_1
30326                 return true;
30327               case 2: //vcc
30328                 return false;
30329               default:
30330                 fatal("op idx %i out of bounds\n", opIdx);
30331                 return false;
30332             }
30333         } // isSrcOperand
30334
30335         bool
30336         isDstOperand(int opIdx) override
30337         {
30338             switch (opIdx) {
30339               case 0: //src_0
30340                 return false;
30341               case 1: //src_1
30342                 return false;
30343               case 2: //vcc
30344                 return true;
30345               default:
30346                 fatal("op idx %i out of bounds\n", opIdx);
30347                 return false;
30348             }
30349         } // isDstOperand
30350
30351         void execute(GPUDynInstPtr) override;
30352     }; // Inst_VOPC__V_CMP_GT_I64
30353
30354     class Inst_VOPC__V_CMP_NE_I64 : public Inst_VOPC
30355     {
30356       public:
30357         Inst_VOPC__V_CMP_NE_I64(InFmt_VOPC*);
30358         ~Inst_VOPC__V_CMP_NE_I64();
30359
30360         int
30361         getNumOperands() override
30362         {
30363             return numDstRegOperands() + numSrcRegOperands();
30364         } // getNumOperands
30365
30366         int numDstRegOperands() override { return 1; }
30367         int numSrcRegOperands() override { return 2; }
30368
30369         int
30370         getOperandSize(int opIdx) override
30371         {
30372             switch (opIdx) {
30373               case 0: //src_0
30374                 return 8;
30375               case 1: //src_1
30376                 return 8;
30377               case 2: //vcc
30378                 return 8;
30379               default:
30380                 fatal("op idx %i out of bounds\n", opIdx);
30381                 return -1;
30382             }
30383         } // getOperandSize
30384
30385         bool
30386         isSrcOperand(int opIdx) override
30387         {
30388             switch (opIdx) {
30389               case 0: //src_0
30390                 return true;
30391               case 1: //src_1
30392                 return true;
30393               case 2: //vcc
30394                 return false;
30395               default:
30396                 fatal("op idx %i out of bounds\n", opIdx);
30397                 return false;
30398             }
30399         } // isSrcOperand
30400
30401         bool
30402         isDstOperand(int opIdx) override
30403         {
30404             switch (opIdx) {
30405               case 0: //src_0
30406                 return false;
30407               case 1: //src_1
30408                 return false;
30409               case 2: //vcc
30410                 return true;
30411               default:
30412                 fatal("op idx %i out of bounds\n", opIdx);
30413                 return false;
30414             }
30415         } // isDstOperand
30416
30417         void execute(GPUDynInstPtr) override;
30418     }; // Inst_VOPC__V_CMP_NE_I64
30419
30420     class Inst_VOPC__V_CMP_GE_I64 : public Inst_VOPC
30421     {
30422       public:
30423         Inst_VOPC__V_CMP_GE_I64(InFmt_VOPC*);
30424         ~Inst_VOPC__V_CMP_GE_I64();
30425
30426         int
30427         getNumOperands() override
30428         {
30429             return numDstRegOperands() + numSrcRegOperands();
30430         } // getNumOperands
30431
30432         int numDstRegOperands() override { return 1; }
30433         int numSrcRegOperands() override { return 2; }
30434
30435         int
30436         getOperandSize(int opIdx) override
30437         {
30438             switch (opIdx) {
30439               case 0: //src_0
30440                 return 8;
30441               case 1: //src_1
30442                 return 8;
30443               case 2: //vcc
30444                 return 8;
30445               default:
30446                 fatal("op idx %i out of bounds\n", opIdx);
30447                 return -1;
30448             }
30449         } // getOperandSize
30450
30451         bool
30452         isSrcOperand(int opIdx) override
30453         {
30454             switch (opIdx) {
30455               case 0: //src_0
30456                 return true;
30457               case 1: //src_1
30458                 return true;
30459               case 2: //vcc
30460                 return false;
30461               default:
30462                 fatal("op idx %i out of bounds\n", opIdx);
30463                 return false;
30464             }
30465         } // isSrcOperand
30466
30467         bool
30468         isDstOperand(int opIdx) override
30469         {
30470             switch (opIdx) {
30471               case 0: //src_0
30472                 return false;
30473               case 1: //src_1
30474                 return false;
30475               case 2: //vcc
30476                 return true;
30477               default:
30478                 fatal("op idx %i out of bounds\n", opIdx);
30479                 return false;
30480             }
30481         } // isDstOperand
30482
30483         void execute(GPUDynInstPtr) override;
30484     }; // Inst_VOPC__V_CMP_GE_I64
30485
30486     class Inst_VOPC__V_CMP_T_I64 : public Inst_VOPC
30487     {
30488       public:
30489         Inst_VOPC__V_CMP_T_I64(InFmt_VOPC*);
30490         ~Inst_VOPC__V_CMP_T_I64();
30491
30492         int
30493         getNumOperands() override
30494         {
30495             return numDstRegOperands() + numSrcRegOperands();
30496         } // getNumOperands
30497
30498         int numDstRegOperands() override { return 1; }
30499         int numSrcRegOperands() override { return 2; }
30500
30501         int
30502         getOperandSize(int opIdx) override
30503         {
30504             switch (opIdx) {
30505               case 0: //src_0
30506                 return 8;
30507               case 1: //src_1
30508                 return 8;
30509               case 2: //vcc
30510                 return 8;
30511               default:
30512                 fatal("op idx %i out of bounds\n", opIdx);
30513                 return -1;
30514             }
30515         } // getOperandSize
30516
30517         bool
30518         isSrcOperand(int opIdx) override
30519         {
30520             switch (opIdx) {
30521               case 0: //src_0
30522                 return true;
30523               case 1: //src_1
30524                 return true;
30525               case 2: //vcc
30526                 return false;
30527               default:
30528                 fatal("op idx %i out of bounds\n", opIdx);
30529                 return false;
30530             }
30531         } // isSrcOperand
30532
30533         bool
30534         isDstOperand(int opIdx) override
30535         {
30536             switch (opIdx) {
30537               case 0: //src_0
30538                 return false;
30539               case 1: //src_1
30540                 return false;
30541               case 2: //vcc
30542                 return true;
30543               default:
30544                 fatal("op idx %i out of bounds\n", opIdx);
30545                 return false;
30546             }
30547         } // isDstOperand
30548
30549         void execute(GPUDynInstPtr) override;
30550     }; // Inst_VOPC__V_CMP_T_I64
30551
30552     class Inst_VOPC__V_CMP_F_U64 : public Inst_VOPC
30553     {
30554       public:
30555         Inst_VOPC__V_CMP_F_U64(InFmt_VOPC*);
30556         ~Inst_VOPC__V_CMP_F_U64();
30557
30558         int
30559         getNumOperands() override
30560         {
30561             return numDstRegOperands() + numSrcRegOperands();
30562         } // getNumOperands
30563
30564         int numDstRegOperands() override { return 1; }
30565         int numSrcRegOperands() override { return 2; }
30566
30567         int
30568         getOperandSize(int opIdx) override
30569         {
30570             switch (opIdx) {
30571               case 0: //src_0
30572                 return 8;
30573               case 1: //src_1
30574                 return 8;
30575               case 2: //vcc
30576                 return 8;
30577               default:
30578                 fatal("op idx %i out of bounds\n", opIdx);
30579                 return -1;
30580             }
30581         } // getOperandSize
30582
30583         bool
30584         isSrcOperand(int opIdx) override
30585         {
30586             switch (opIdx) {
30587               case 0: //src_0
30588                 return true;
30589               case 1: //src_1
30590                 return true;
30591               case 2: //vcc
30592                 return false;
30593               default:
30594                 fatal("op idx %i out of bounds\n", opIdx);
30595                 return false;
30596             }
30597         } // isSrcOperand
30598
30599         bool
30600         isDstOperand(int opIdx) override
30601         {
30602             switch (opIdx) {
30603               case 0: //src_0
30604                 return false;
30605               case 1: //src_1
30606                 return false;
30607               case 2: //vcc
30608                 return true;
30609               default:
30610                 fatal("op idx %i out of bounds\n", opIdx);
30611                 return false;
30612             }
30613         } // isDstOperand
30614
30615         void execute(GPUDynInstPtr) override;
30616     }; // Inst_VOPC__V_CMP_F_U64
30617
30618     class Inst_VOPC__V_CMP_LT_U64 : public Inst_VOPC
30619     {
30620       public:
30621         Inst_VOPC__V_CMP_LT_U64(InFmt_VOPC*);
30622         ~Inst_VOPC__V_CMP_LT_U64();
30623
30624         int
30625         getNumOperands() override
30626         {
30627             return numDstRegOperands() + numSrcRegOperands();
30628         } // getNumOperands
30629
30630         int numDstRegOperands() override { return 1; }
30631         int numSrcRegOperands() override { return 2; }
30632
30633         int
30634         getOperandSize(int opIdx) override
30635         {
30636             switch (opIdx) {
30637               case 0: //src_0
30638                 return 8;
30639               case 1: //src_1
30640                 return 8;
30641               case 2: //vcc
30642                 return 8;
30643               default:
30644                 fatal("op idx %i out of bounds\n", opIdx);
30645                 return -1;
30646             }
30647         } // getOperandSize
30648
30649         bool
30650         isSrcOperand(int opIdx) override
30651         {
30652             switch (opIdx) {
30653               case 0: //src_0
30654                 return true;
30655               case 1: //src_1
30656                 return true;
30657               case 2: //vcc
30658                 return false;
30659               default:
30660                 fatal("op idx %i out of bounds\n", opIdx);
30661                 return false;
30662             }
30663         } // isSrcOperand
30664
30665         bool
30666         isDstOperand(int opIdx) override
30667         {
30668             switch (opIdx) {
30669               case 0: //src_0
30670                 return false;
30671               case 1: //src_1
30672                 return false;
30673               case 2: //vcc
30674                 return true;
30675               default:
30676                 fatal("op idx %i out of bounds\n", opIdx);
30677                 return false;
30678             }
30679         } // isDstOperand
30680
30681         void execute(GPUDynInstPtr) override;
30682     }; // Inst_VOPC__V_CMP_LT_U64
30683
30684     class Inst_VOPC__V_CMP_EQ_U64 : public Inst_VOPC
30685     {
30686       public:
30687         Inst_VOPC__V_CMP_EQ_U64(InFmt_VOPC*);
30688         ~Inst_VOPC__V_CMP_EQ_U64();
30689
30690         int
30691         getNumOperands() override
30692         {
30693             return numDstRegOperands() + numSrcRegOperands();
30694         } // getNumOperands
30695
30696         int numDstRegOperands() override { return 1; }
30697         int numSrcRegOperands() override { return 2; }
30698
30699         int
30700         getOperandSize(int opIdx) override
30701         {
30702             switch (opIdx) {
30703               case 0: //src_0
30704                 return 8;
30705               case 1: //src_1
30706                 return 8;
30707               case 2: //vcc
30708                 return 8;
30709               default:
30710                 fatal("op idx %i out of bounds\n", opIdx);
30711                 return -1;
30712             }
30713         } // getOperandSize
30714
30715         bool
30716         isSrcOperand(int opIdx) override
30717         {
30718             switch (opIdx) {
30719               case 0: //src_0
30720                 return true;
30721               case 1: //src_1
30722                 return true;
30723               case 2: //vcc
30724                 return false;
30725               default:
30726                 fatal("op idx %i out of bounds\n", opIdx);
30727                 return false;
30728             }
30729         } // isSrcOperand
30730
30731         bool
30732         isDstOperand(int opIdx) override
30733         {
30734             switch (opIdx) {
30735               case 0: //src_0
30736                 return false;
30737               case 1: //src_1
30738                 return false;
30739               case 2: //vcc
30740                 return true;
30741               default:
30742                 fatal("op idx %i out of bounds\n", opIdx);
30743                 return false;
30744             }
30745         } // isDstOperand
30746
30747         void execute(GPUDynInstPtr) override;
30748     }; // Inst_VOPC__V_CMP_EQ_U64
30749
30750     class Inst_VOPC__V_CMP_LE_U64 : public Inst_VOPC
30751     {
30752       public:
30753         Inst_VOPC__V_CMP_LE_U64(InFmt_VOPC*);
30754         ~Inst_VOPC__V_CMP_LE_U64();
30755
30756         int
30757         getNumOperands() override
30758         {
30759             return numDstRegOperands() + numSrcRegOperands();
30760         } // getNumOperands
30761
30762         int numDstRegOperands() override { return 1; }
30763         int numSrcRegOperands() override { return 2; }
30764
30765         int
30766         getOperandSize(int opIdx) override
30767         {
30768             switch (opIdx) {
30769               case 0: //src_0
30770                 return 8;
30771               case 1: //src_1
30772                 return 8;
30773               case 2: //vcc
30774                 return 8;
30775               default:
30776                 fatal("op idx %i out of bounds\n", opIdx);
30777                 return -1;
30778             }
30779         } // getOperandSize
30780
30781         bool
30782         isSrcOperand(int opIdx) override
30783         {
30784             switch (opIdx) {
30785               case 0: //src_0
30786                 return true;
30787               case 1: //src_1
30788                 return true;
30789               case 2: //vcc
30790                 return false;
30791               default:
30792                 fatal("op idx %i out of bounds\n", opIdx);
30793                 return false;
30794             }
30795         } // isSrcOperand
30796
30797         bool
30798         isDstOperand(int opIdx) override
30799         {
30800             switch (opIdx) {
30801               case 0: //src_0
30802                 return false;
30803               case 1: //src_1
30804                 return false;
30805               case 2: //vcc
30806                 return true;
30807               default:
30808                 fatal("op idx %i out of bounds\n", opIdx);
30809                 return false;
30810             }
30811         } // isDstOperand
30812
30813         void execute(GPUDynInstPtr) override;
30814     }; // Inst_VOPC__V_CMP_LE_U64
30815
30816     class Inst_VOPC__V_CMP_GT_U64 : public Inst_VOPC
30817     {
30818       public:
30819         Inst_VOPC__V_CMP_GT_U64(InFmt_VOPC*);
30820         ~Inst_VOPC__V_CMP_GT_U64();
30821
30822         int
30823         getNumOperands() override
30824         {
30825             return numDstRegOperands() + numSrcRegOperands();
30826         } // getNumOperands
30827
30828         int numDstRegOperands() override { return 1; }
30829         int numSrcRegOperands() override { return 2; }
30830
30831         int
30832         getOperandSize(int opIdx) override
30833         {
30834             switch (opIdx) {
30835               case 0: //src_0
30836                 return 8;
30837               case 1: //src_1
30838                 return 8;
30839               case 2: //vcc
30840                 return 8;
30841               default:
30842                 fatal("op idx %i out of bounds\n", opIdx);
30843                 return -1;
30844             }
30845         } // getOperandSize
30846
30847         bool
30848         isSrcOperand(int opIdx) override
30849         {
30850             switch (opIdx) {
30851               case 0: //src_0
30852                 return true;
30853               case 1: //src_1
30854                 return true;
30855               case 2: //vcc
30856                 return false;
30857               default:
30858                 fatal("op idx %i out of bounds\n", opIdx);
30859                 return false;
30860             }
30861         } // isSrcOperand
30862
30863         bool
30864         isDstOperand(int opIdx) override
30865         {
30866             switch (opIdx) {
30867               case 0: //src_0
30868                 return false;
30869               case 1: //src_1
30870                 return false;
30871               case 2: //vcc
30872                 return true;
30873               default:
30874                 fatal("op idx %i out of bounds\n", opIdx);
30875                 return false;
30876             }
30877         } // isDstOperand
30878
30879         void execute(GPUDynInstPtr) override;
30880     }; // Inst_VOPC__V_CMP_GT_U64
30881
30882     class Inst_VOPC__V_CMP_NE_U64 : public Inst_VOPC
30883     {
30884       public:
30885         Inst_VOPC__V_CMP_NE_U64(InFmt_VOPC*);
30886         ~Inst_VOPC__V_CMP_NE_U64();
30887
30888         int
30889         getNumOperands() override
30890         {
30891             return numDstRegOperands() + numSrcRegOperands();
30892         } // getNumOperands
30893
30894         int numDstRegOperands() override { return 1; }
30895         int numSrcRegOperands() override { return 2; }
30896
30897         int
30898         getOperandSize(int opIdx) override
30899         {
30900             switch (opIdx) {
30901               case 0: //src_0
30902                 return 8;
30903               case 1: //src_1
30904                 return 8;
30905               case 2: //vcc
30906                 return 8;
30907               default:
30908                 fatal("op idx %i out of bounds\n", opIdx);
30909                 return -1;
30910             }
30911         } // getOperandSize
30912
30913         bool
30914         isSrcOperand(int opIdx) override
30915         {
30916             switch (opIdx) {
30917               case 0: //src_0
30918                 return true;
30919               case 1: //src_1
30920                 return true;
30921               case 2: //vcc
30922                 return false;
30923               default:
30924                 fatal("op idx %i out of bounds\n", opIdx);
30925                 return false;
30926             }
30927         } // isSrcOperand
30928
30929         bool
30930         isDstOperand(int opIdx) override
30931         {
30932             switch (opIdx) {
30933               case 0: //src_0
30934                 return false;
30935               case 1: //src_1
30936                 return false;
30937               case 2: //vcc
30938                 return true;
30939               default:
30940                 fatal("op idx %i out of bounds\n", opIdx);
30941                 return false;
30942             }
30943         } // isDstOperand
30944
30945         void execute(GPUDynInstPtr) override;
30946     }; // Inst_VOPC__V_CMP_NE_U64
30947
30948     class Inst_VOPC__V_CMP_GE_U64 : public Inst_VOPC
30949     {
30950       public:
30951         Inst_VOPC__V_CMP_GE_U64(InFmt_VOPC*);
30952         ~Inst_VOPC__V_CMP_GE_U64();
30953
30954         int
30955         getNumOperands() override
30956         {
30957             return numDstRegOperands() + numSrcRegOperands();
30958         } // getNumOperands
30959
30960         int numDstRegOperands() override { return 1; }
30961         int numSrcRegOperands() override { return 2; }
30962
30963         int
30964         getOperandSize(int opIdx) override
30965         {
30966             switch (opIdx) {
30967               case 0: //src_0
30968                 return 8;
30969               case 1: //src_1
30970                 return 8;
30971               case 2: //vcc
30972                 return 8;
30973               default:
30974                 fatal("op idx %i out of bounds\n", opIdx);
30975                 return -1;
30976             }
30977         } // getOperandSize
30978
30979         bool
30980         isSrcOperand(int opIdx) override
30981         {
30982             switch (opIdx) {
30983               case 0: //src_0
30984                 return true;
30985               case 1: //src_1
30986                 return true;
30987               case 2: //vcc
30988                 return false;
30989               default:
30990                 fatal("op idx %i out of bounds\n", opIdx);
30991                 return false;
30992             }
30993         } // isSrcOperand
30994
30995         bool
30996         isDstOperand(int opIdx) override
30997         {
30998             switch (opIdx) {
30999               case 0: //src_0
31000                 return false;
31001               case 1: //src_1
31002                 return false;
31003               case 2: //vcc
31004                 return true;
31005               default:
31006                 fatal("op idx %i out of bounds\n", opIdx);
31007                 return false;
31008             }
31009         } // isDstOperand
31010
31011         void execute(GPUDynInstPtr) override;
31012     }; // Inst_VOPC__V_CMP_GE_U64
31013
31014     class Inst_VOPC__V_CMP_T_U64 : public Inst_VOPC
31015     {
31016       public:
31017         Inst_VOPC__V_CMP_T_U64(InFmt_VOPC*);
31018         ~Inst_VOPC__V_CMP_T_U64();
31019
31020         int
31021         getNumOperands() override
31022         {
31023             return numDstRegOperands() + numSrcRegOperands();
31024         } // getNumOperands
31025
31026         int numDstRegOperands() override { return 1; }
31027         int numSrcRegOperands() override { return 2; }
31028
31029         int
31030         getOperandSize(int opIdx) override
31031         {
31032             switch (opIdx) {
31033               case 0: //src_0
31034                 return 8;
31035               case 1: //src_1
31036                 return 8;
31037               case 2: //vcc
31038                 return 8;
31039               default:
31040                 fatal("op idx %i out of bounds\n", opIdx);
31041                 return -1;
31042             }
31043         } // getOperandSize
31044
31045         bool
31046         isSrcOperand(int opIdx) override
31047         {
31048             switch (opIdx) {
31049               case 0: //src_0
31050                 return true;
31051               case 1: //src_1
31052                 return true;
31053               case 2: //vcc
31054                 return false;
31055               default:
31056                 fatal("op idx %i out of bounds\n", opIdx);
31057                 return false;
31058             }
31059         } // isSrcOperand
31060
31061         bool
31062         isDstOperand(int opIdx) override
31063         {
31064             switch (opIdx) {
31065               case 0: //src_0
31066                 return false;
31067               case 1: //src_1
31068                 return false;
31069               case 2: //vcc
31070                 return true;
31071               default:
31072                 fatal("op idx %i out of bounds\n", opIdx);
31073                 return false;
31074             }
31075         } // isDstOperand
31076
31077         void execute(GPUDynInstPtr) override;
31078     }; // Inst_VOPC__V_CMP_T_U64
31079
31080     class Inst_VOPC__V_CMPX_F_I64 : public Inst_VOPC
31081     {
31082       public:
31083         Inst_VOPC__V_CMPX_F_I64(InFmt_VOPC*);
31084         ~Inst_VOPC__V_CMPX_F_I64();
31085
31086         int
31087         getNumOperands() override
31088         {
31089             return numDstRegOperands() + numSrcRegOperands();
31090         } // getNumOperands
31091
31092         int numDstRegOperands() override { return 1; }
31093         int numSrcRegOperands() override { return 2; }
31094
31095         int
31096         getOperandSize(int opIdx) override
31097         {
31098             switch (opIdx) {
31099               case 0: //src_0
31100                 return 8;
31101               case 1: //src_1
31102                 return 8;
31103               case 2: //vcc
31104                 return 8;
31105               default:
31106                 fatal("op idx %i out of bounds\n", opIdx);
31107                 return -1;
31108             }
31109         } // getOperandSize
31110
31111         bool
31112         isSrcOperand(int opIdx) override
31113         {
31114             switch (opIdx) {
31115               case 0: //src_0
31116                 return true;
31117               case 1: //src_1
31118                 return true;
31119               default:
31120                 fatal("op idx %i out of bounds\n", opIdx);
31121                 return false;
31122             }
31123         } // isSrcOperand
31124
31125         bool
31126         isDstOperand(int opIdx) override
31127         {
31128             switch (opIdx) {
31129               case 0: //src_0
31130                 return false;
31131               case 1: //src_1
31132                 return false;
31133               default:
31134                 fatal("op idx %i out of bounds\n", opIdx);
31135                 return false;
31136             }
31137         } // isDstOperand
31138
31139         void execute(GPUDynInstPtr) override;
31140     }; // Inst_VOPC__V_CMPX_F_I64
31141
31142     class Inst_VOPC__V_CMPX_LT_I64 : public Inst_VOPC
31143     {
31144       public:
31145         Inst_VOPC__V_CMPX_LT_I64(InFmt_VOPC*);
31146         ~Inst_VOPC__V_CMPX_LT_I64();
31147
31148         int
31149         getNumOperands() override
31150         {
31151             return numDstRegOperands() + numSrcRegOperands();
31152         } // getNumOperands
31153
31154         int numDstRegOperands() override { return 1; }
31155         int numSrcRegOperands() override { return 2; }
31156
31157         int
31158         getOperandSize(int opIdx) override
31159         {
31160             switch (opIdx) {
31161               case 0: //src_0
31162                 return 8;
31163               case 1: //src_1
31164                 return 8;
31165               case 2: //vcc
31166                 return 8;
31167               default:
31168                 fatal("op idx %i out of bounds\n", opIdx);
31169                 return -1;
31170             }
31171         } // getOperandSize
31172
31173         bool
31174         isSrcOperand(int opIdx) override
31175         {
31176             switch (opIdx) {
31177               case 0: //src_0
31178                 return true;
31179               case 1: //src_1
31180                 return true;
31181               default:
31182                 fatal("op idx %i out of bounds\n", opIdx);
31183                 return false;
31184             }
31185         } // isSrcOperand
31186
31187         bool
31188         isDstOperand(int opIdx) override
31189         {
31190             switch (opIdx) {
31191               case 0: //src_0
31192                 return false;
31193               case 1: //src_1
31194                 return false;
31195               default:
31196                 fatal("op idx %i out of bounds\n", opIdx);
31197                 return false;
31198             }
31199         } // isDstOperand
31200
31201         void execute(GPUDynInstPtr) override;
31202     }; // Inst_VOPC__V_CMPX_LT_I64
31203
31204     class Inst_VOPC__V_CMPX_EQ_I64 : public Inst_VOPC
31205     {
31206       public:
31207         Inst_VOPC__V_CMPX_EQ_I64(InFmt_VOPC*);
31208         ~Inst_VOPC__V_CMPX_EQ_I64();
31209
31210         int
31211         getNumOperands() override
31212         {
31213             return numDstRegOperands() + numSrcRegOperands();
31214         } // getNumOperands
31215
31216         int numDstRegOperands() override { return 1; }
31217         int numSrcRegOperands() override { return 2; }
31218
31219         int
31220         getOperandSize(int opIdx) override
31221         {
31222             switch (opIdx) {
31223               case 0: //src_0
31224                 return 8;
31225               case 1: //src_1
31226                 return 8;
31227               case 2: //vcc
31228                 return 8;
31229               default:
31230                 fatal("op idx %i out of bounds\n", opIdx);
31231                 return -1;
31232             }
31233         } // getOperandSize
31234
31235         bool
31236         isSrcOperand(int opIdx) override
31237         {
31238             switch (opIdx) {
31239               case 0: //src_0
31240                 return true;
31241               case 1: //src_1
31242                 return true;
31243               default:
31244                 fatal("op idx %i out of bounds\n", opIdx);
31245                 return false;
31246             }
31247         } // isSrcOperand
31248
31249         bool
31250         isDstOperand(int opIdx) override
31251         {
31252             switch (opIdx) {
31253               case 0: //src_0
31254                 return false;
31255               case 1: //src_1
31256                 return false;
31257               default:
31258                 fatal("op idx %i out of bounds\n", opIdx);
31259                 return false;
31260             }
31261         } // isDstOperand
31262
31263         void execute(GPUDynInstPtr) override;
31264     }; // Inst_VOPC__V_CMPX_EQ_I64
31265
31266     class Inst_VOPC__V_CMPX_LE_I64 : public Inst_VOPC
31267     {
31268       public:
31269         Inst_VOPC__V_CMPX_LE_I64(InFmt_VOPC*);
31270         ~Inst_VOPC__V_CMPX_LE_I64();
31271
31272         int
31273         getNumOperands() override
31274         {
31275             return numDstRegOperands() + numSrcRegOperands();
31276         } // getNumOperands
31277
31278         int numDstRegOperands() override { return 1; }
31279         int numSrcRegOperands() override { return 2; }
31280
31281         int
31282         getOperandSize(int opIdx) override
31283         {
31284             switch (opIdx) {
31285               case 0: //src_0
31286                 return 8;
31287               case 1: //src_1
31288                 return 8;
31289               case 2: //vcc
31290                 return 8;
31291               default:
31292                 fatal("op idx %i out of bounds\n", opIdx);
31293                 return -1;
31294             }
31295         } // getOperandSize
31296
31297         bool
31298         isSrcOperand(int opIdx) override
31299         {
31300             switch (opIdx) {
31301               case 0: //src_0
31302                 return true;
31303               case 1: //src_1
31304                 return true;
31305               default:
31306                 fatal("op idx %i out of bounds\n", opIdx);
31307                 return false;
31308             }
31309         } // isSrcOperand
31310
31311         bool
31312         isDstOperand(int opIdx) override
31313         {
31314             switch (opIdx) {
31315               case 0: //src_0
31316                 return false;
31317               case 1: //src_1
31318                 return false;
31319               default:
31320                 fatal("op idx %i out of bounds\n", opIdx);
31321                 return false;
31322             }
31323         } // isDstOperand
31324
31325         void execute(GPUDynInstPtr) override;
31326     }; // Inst_VOPC__V_CMPX_LE_I64
31327
31328     class Inst_VOPC__V_CMPX_GT_I64 : public Inst_VOPC
31329     {
31330       public:
31331         Inst_VOPC__V_CMPX_GT_I64(InFmt_VOPC*);
31332         ~Inst_VOPC__V_CMPX_GT_I64();
31333
31334         int
31335         getNumOperands() override
31336         {
31337             return numDstRegOperands() + numSrcRegOperands();
31338         } // getNumOperands
31339
31340         int numDstRegOperands() override { return 1; }
31341         int numSrcRegOperands() override { return 2; }
31342
31343         int
31344         getOperandSize(int opIdx) override
31345         {
31346             switch (opIdx) {
31347               case 0: //src_0
31348                 return 8;
31349               case 1: //src_1
31350                 return 8;
31351               case 2: //vcc
31352                 return 8;
31353               default:
31354                 fatal("op idx %i out of bounds\n", opIdx);
31355                 return -1;
31356             }
31357         } // getOperandSize
31358
31359         bool
31360         isSrcOperand(int opIdx) override
31361         {
31362             switch (opIdx) {
31363               case 0: //src_0
31364                 return true;
31365               case 1: //src_1
31366                 return true;
31367               default:
31368                 fatal("op idx %i out of bounds\n", opIdx);
31369                 return false;
31370             }
31371         } // isSrcOperand
31372
31373         bool
31374         isDstOperand(int opIdx) override
31375         {
31376             switch (opIdx) {
31377               case 0: //src_0
31378                 return false;
31379               case 1: //src_1
31380                 return false;
31381               default:
31382                 fatal("op idx %i out of bounds\n", opIdx);
31383                 return false;
31384             }
31385         } // isDstOperand
31386
31387         void execute(GPUDynInstPtr) override;
31388     }; // Inst_VOPC__V_CMPX_GT_I64
31389
31390     class Inst_VOPC__V_CMPX_NE_I64 : public Inst_VOPC
31391     {
31392       public:
31393         Inst_VOPC__V_CMPX_NE_I64(InFmt_VOPC*);
31394         ~Inst_VOPC__V_CMPX_NE_I64();
31395
31396         int
31397         getNumOperands() override
31398         {
31399             return numDstRegOperands() + numSrcRegOperands();
31400         } // getNumOperands
31401
31402         int numDstRegOperands() override { return 1; }
31403         int numSrcRegOperands() override { return 2; }
31404
31405         int
31406         getOperandSize(int opIdx) override
31407         {
31408             switch (opIdx) {
31409               case 0: //src_0
31410                 return 8;
31411               case 1: //src_1
31412                 return 8;
31413               case 2: //vcc
31414                 return 8;
31415               default:
31416                 fatal("op idx %i out of bounds\n", opIdx);
31417                 return -1;
31418             }
31419         } // getOperandSize
31420
31421         bool
31422         isSrcOperand(int opIdx) override
31423         {
31424             switch (opIdx) {
31425               case 0: //src_0
31426                 return true;
31427               case 1: //src_1
31428                 return true;
31429               default:
31430                 fatal("op idx %i out of bounds\n", opIdx);
31431                 return false;
31432             }
31433         } // isSrcOperand
31434
31435         bool
31436         isDstOperand(int opIdx) override
31437         {
31438             switch (opIdx) {
31439               case 0: //src_0
31440                 return false;
31441               case 1: //src_1
31442                 return false;
31443               default:
31444                 fatal("op idx %i out of bounds\n", opIdx);
31445                 return false;
31446             }
31447         } // isDstOperand
31448
31449         void execute(GPUDynInstPtr) override;
31450     }; // Inst_VOPC__V_CMPX_NE_I64
31451
31452     class Inst_VOPC__V_CMPX_GE_I64 : public Inst_VOPC
31453     {
31454       public:
31455         Inst_VOPC__V_CMPX_GE_I64(InFmt_VOPC*);
31456         ~Inst_VOPC__V_CMPX_GE_I64();
31457
31458         int
31459         getNumOperands() override
31460         {
31461             return numDstRegOperands() + numSrcRegOperands();
31462         } // getNumOperands
31463
31464         int numDstRegOperands() override { return 1; }
31465         int numSrcRegOperands() override { return 2; }
31466
31467         int
31468         getOperandSize(int opIdx) override
31469         {
31470             switch (opIdx) {
31471               case 0: //src_0
31472                 return 8;
31473               case 1: //src_1
31474                 return 8;
31475               case 2: //vcc
31476                 return 8;
31477               default:
31478                 fatal("op idx %i out of bounds\n", opIdx);
31479                 return -1;
31480             }
31481         } // getOperandSize
31482
31483         bool
31484         isSrcOperand(int opIdx) override
31485         {
31486             switch (opIdx) {
31487               case 0: //src_0
31488                 return true;
31489               case 1: //src_1
31490                 return true;
31491               default:
31492                 fatal("op idx %i out of bounds\n", opIdx);
31493                 return false;
31494             }
31495         } // isSrcOperand
31496
31497         bool
31498         isDstOperand(int opIdx) override
31499         {
31500             switch (opIdx) {
31501               case 0: //src_0
31502                 return false;
31503               case 1: //src_1
31504                 return false;
31505               default:
31506                 fatal("op idx %i out of bounds\n", opIdx);
31507                 return false;
31508             }
31509         } // isDstOperand
31510
31511         void execute(GPUDynInstPtr) override;
31512     }; // Inst_VOPC__V_CMPX_GE_I64
31513
31514     class Inst_VOPC__V_CMPX_T_I64 : public Inst_VOPC
31515     {
31516       public:
31517         Inst_VOPC__V_CMPX_T_I64(InFmt_VOPC*);
31518         ~Inst_VOPC__V_CMPX_T_I64();
31519
31520         int
31521         getNumOperands() override
31522         {
31523             return numDstRegOperands() + numSrcRegOperands();
31524         } // getNumOperands
31525
31526         int numDstRegOperands() override { return 1; }
31527         int numSrcRegOperands() override { return 2; }
31528
31529         int
31530         getOperandSize(int opIdx) override
31531         {
31532             switch (opIdx) {
31533               case 0: //src_0
31534                 return 8;
31535               case 1: //src_1
31536                 return 8;
31537               case 2: //vcc
31538                 return 8;
31539               default:
31540                 fatal("op idx %i out of bounds\n", opIdx);
31541                 return -1;
31542             }
31543         } // getOperandSize
31544
31545         bool
31546         isSrcOperand(int opIdx) override
31547         {
31548             switch (opIdx) {
31549               case 0: //src_0
31550                 return true;
31551               case 1: //src_1
31552                 return true;
31553               default:
31554                 fatal("op idx %i out of bounds\n", opIdx);
31555                 return false;
31556             }
31557         } // isSrcOperand
31558
31559         bool
31560         isDstOperand(int opIdx) override
31561         {
31562             switch (opIdx) {
31563               case 0: //src_0
31564                 return false;
31565               case 1: //src_1
31566                 return false;
31567               default:
31568                 fatal("op idx %i out of bounds\n", opIdx);
31569                 return false;
31570             }
31571         } // isDstOperand
31572
31573         void execute(GPUDynInstPtr) override;
31574     }; // Inst_VOPC__V_CMPX_T_I64
31575
31576     class Inst_VOPC__V_CMPX_F_U64 : public Inst_VOPC
31577     {
31578       public:
31579         Inst_VOPC__V_CMPX_F_U64(InFmt_VOPC*);
31580         ~Inst_VOPC__V_CMPX_F_U64();
31581
31582         int
31583         getNumOperands() override
31584         {
31585             return numDstRegOperands() + numSrcRegOperands();
31586         } // getNumOperands
31587
31588         int numDstRegOperands() override { return 1; }
31589         int numSrcRegOperands() override { return 2; }
31590
31591         int
31592         getOperandSize(int opIdx) override
31593         {
31594             switch (opIdx) {
31595               case 0: //src_0
31596                 return 8;
31597               case 1: //src_1
31598                 return 8;
31599               case 2: //vcc
31600                 return 8;
31601               default:
31602                 fatal("op idx %i out of bounds\n", opIdx);
31603                 return -1;
31604             }
31605         } // getOperandSize
31606
31607         bool
31608         isSrcOperand(int opIdx) override
31609         {
31610             switch (opIdx) {
31611               case 0: //src_0
31612                 return true;
31613               case 1: //src_1
31614                 return true;
31615               default:
31616                 fatal("op idx %i out of bounds\n", opIdx);
31617                 return false;
31618             }
31619         } // isSrcOperand
31620
31621         bool
31622         isDstOperand(int opIdx) override
31623         {
31624             switch (opIdx) {
31625               case 0: //src_0
31626                 return false;
31627               case 1: //src_1
31628                 return false;
31629               default:
31630                 fatal("op idx %i out of bounds\n", opIdx);
31631                 return false;
31632             }
31633         } // isDstOperand
31634
31635         void execute(GPUDynInstPtr) override;
31636     }; // Inst_VOPC__V_CMPX_F_U64
31637
31638     class Inst_VOPC__V_CMPX_LT_U64 : public Inst_VOPC
31639     {
31640       public:
31641         Inst_VOPC__V_CMPX_LT_U64(InFmt_VOPC*);
31642         ~Inst_VOPC__V_CMPX_LT_U64();
31643
31644         int
31645         getNumOperands() override
31646         {
31647             return numDstRegOperands() + numSrcRegOperands();
31648         } // getNumOperands
31649
31650         int numDstRegOperands() override { return 1; }
31651         int numSrcRegOperands() override { return 2; }
31652
31653         int
31654         getOperandSize(int opIdx) override
31655         {
31656             switch (opIdx) {
31657               case 0: //src_0
31658                 return 8;
31659               case 1: //src_1
31660                 return 8;
31661               case 2: //vcc
31662                 return 8;
31663               default:
31664                 fatal("op idx %i out of bounds\n", opIdx);
31665                 return -1;
31666             }
31667         } // getOperandSize
31668
31669         bool
31670         isSrcOperand(int opIdx) override
31671         {
31672             switch (opIdx) {
31673               case 0: //src_0
31674                 return true;
31675               case 1: //src_1
31676                 return true;
31677               default:
31678                 fatal("op idx %i out of bounds\n", opIdx);
31679                 return false;
31680             }
31681         } // isSrcOperand
31682
31683         bool
31684         isDstOperand(int opIdx) override
31685         {
31686             switch (opIdx) {
31687               case 0: //src_0
31688                 return false;
31689               case 1: //src_1
31690                 return false;
31691               default:
31692                 fatal("op idx %i out of bounds\n", opIdx);
31693                 return false;
31694             }
31695         } // isDstOperand
31696
31697         void execute(GPUDynInstPtr) override;
31698     }; // Inst_VOPC__V_CMPX_LT_U64
31699
31700     class Inst_VOPC__V_CMPX_EQ_U64 : public Inst_VOPC
31701     {
31702       public:
31703         Inst_VOPC__V_CMPX_EQ_U64(InFmt_VOPC*);
31704         ~Inst_VOPC__V_CMPX_EQ_U64();
31705
31706         int
31707         getNumOperands() override
31708         {
31709             return numDstRegOperands() + numSrcRegOperands();
31710         } // getNumOperands
31711
31712         int numDstRegOperands() override { return 1; }
31713         int numSrcRegOperands() override { return 2; }
31714
31715         int
31716         getOperandSize(int opIdx) override
31717         {
31718             switch (opIdx) {
31719               case 0: //src_0
31720                 return 8;
31721               case 1: //src_1
31722                 return 8;
31723               case 2: //vcc
31724                 return 8;
31725               default:
31726                 fatal("op idx %i out of bounds\n", opIdx);
31727                 return -1;
31728             }
31729         } // getOperandSize
31730
31731         bool
31732         isSrcOperand(int opIdx) override
31733         {
31734             switch (opIdx) {
31735               case 0: //src_0
31736                 return true;
31737               case 1: //src_1
31738                 return true;
31739               default:
31740                 fatal("op idx %i out of bounds\n", opIdx);
31741                 return false;
31742             }
31743         } // isSrcOperand
31744
31745         bool
31746         isDstOperand(int opIdx) override
31747         {
31748             switch (opIdx) {
31749               case 0: //src_0
31750                 return false;
31751               case 1: //src_1
31752                 return false;
31753               default:
31754                 fatal("op idx %i out of bounds\n", opIdx);
31755                 return false;
31756             }
31757         } // isDstOperand
31758
31759         void execute(GPUDynInstPtr) override;
31760     }; // Inst_VOPC__V_CMPX_EQ_U64
31761
31762     class Inst_VOPC__V_CMPX_LE_U64 : public Inst_VOPC
31763     {
31764       public:
31765         Inst_VOPC__V_CMPX_LE_U64(InFmt_VOPC*);
31766         ~Inst_VOPC__V_CMPX_LE_U64();
31767
31768         int
31769         getNumOperands() override
31770         {
31771             return numDstRegOperands() + numSrcRegOperands();
31772         } // getNumOperands
31773
31774         int numDstRegOperands() override { return 1; }
31775         int numSrcRegOperands() override { return 2; }
31776
31777         int
31778         getOperandSize(int opIdx) override
31779         {
31780             switch (opIdx) {
31781               case 0: //src_0
31782                 return 8;
31783               case 1: //src_1
31784                 return 8;
31785               case 2: //vcc
31786                 return 8;
31787               default:
31788                 fatal("op idx %i out of bounds\n", opIdx);
31789                 return -1;
31790             }
31791         } // getOperandSize
31792
31793         bool
31794         isSrcOperand(int opIdx) override
31795         {
31796             switch (opIdx) {
31797               case 0: //src_0
31798                 return true;
31799               case 1: //src_1
31800                 return true;
31801               default:
31802                 fatal("op idx %i out of bounds\n", opIdx);
31803                 return false;
31804             }
31805         } // isSrcOperand
31806
31807         bool
31808         isDstOperand(int opIdx) override
31809         {
31810             switch (opIdx) {
31811               case 0: //src_0
31812                 return false;
31813               case 1: //src_1
31814                 return false;
31815               default:
31816                 fatal("op idx %i out of bounds\n", opIdx);
31817                 return false;
31818             }
31819         } // isDstOperand
31820
31821         void execute(GPUDynInstPtr) override;
31822     }; // Inst_VOPC__V_CMPX_LE_U64
31823
31824     class Inst_VOPC__V_CMPX_GT_U64 : public Inst_VOPC
31825     {
31826       public:
31827         Inst_VOPC__V_CMPX_GT_U64(InFmt_VOPC*);
31828         ~Inst_VOPC__V_CMPX_GT_U64();
31829
31830         int
31831         getNumOperands() override
31832         {
31833             return numDstRegOperands() + numSrcRegOperands();
31834         } // getNumOperands
31835
31836         int numDstRegOperands() override { return 1; }
31837         int numSrcRegOperands() override { return 2; }
31838
31839         int
31840         getOperandSize(int opIdx) override
31841         {
31842             switch (opIdx) {
31843               case 0: //src_0
31844                 return 8;
31845               case 1: //src_1
31846                 return 8;
31847               case 2: //vcc
31848                 return 8;
31849               default:
31850                 fatal("op idx %i out of bounds\n", opIdx);
31851                 return -1;
31852             }
31853         } // getOperandSize
31854
31855         bool
31856         isSrcOperand(int opIdx) override
31857         {
31858             switch (opIdx) {
31859               case 0: //src_0
31860                 return true;
31861               case 1: //src_1
31862                 return true;
31863               default:
31864                 fatal("op idx %i out of bounds\n", opIdx);
31865                 return false;
31866             }
31867         } // isSrcOperand
31868
31869         bool
31870         isDstOperand(int opIdx) override
31871         {
31872             switch (opIdx) {
31873               case 0: //src_0
31874                 return false;
31875               case 1: //src_1
31876                 return false;
31877               default:
31878                 fatal("op idx %i out of bounds\n", opIdx);
31879                 return false;
31880             }
31881         } // isDstOperand
31882
31883         void execute(GPUDynInstPtr) override;
31884     }; // Inst_VOPC__V_CMPX_GT_U64
31885
31886     class Inst_VOPC__V_CMPX_NE_U64 : public Inst_VOPC
31887     {
31888       public:
31889         Inst_VOPC__V_CMPX_NE_U64(InFmt_VOPC*);
31890         ~Inst_VOPC__V_CMPX_NE_U64();
31891
31892         int
31893         getNumOperands() override
31894         {
31895             return numDstRegOperands() + numSrcRegOperands();
31896         } // getNumOperands
31897
31898         int numDstRegOperands() override { return 1; }
31899         int numSrcRegOperands() override { return 2; }
31900
31901         int
31902         getOperandSize(int opIdx) override
31903         {
31904             switch (opIdx) {
31905               case 0: //src_0
31906                 return 8;
31907               case 1: //src_1
31908                 return 8;
31909               case 2: //vcc
31910                 return 8;
31911               default:
31912                 fatal("op idx %i out of bounds\n", opIdx);
31913                 return -1;
31914             }
31915         } // getOperandSize
31916
31917         bool
31918         isSrcOperand(int opIdx) override
31919         {
31920             switch (opIdx) {
31921               case 0: //src_0
31922                 return true;
31923               case 1: //src_1
31924                 return true;
31925               default:
31926                 fatal("op idx %i out of bounds\n", opIdx);
31927                 return false;
31928             }
31929         } // isSrcOperand
31930
31931         bool
31932         isDstOperand(int opIdx) override
31933         {
31934             switch (opIdx) {
31935               case 0: //src_0
31936                 return false;
31937               case 1: //src_1
31938                 return false;
31939               default:
31940                 fatal("op idx %i out of bounds\n", opIdx);
31941                 return false;
31942             }
31943         } // isDstOperand
31944
31945         void execute(GPUDynInstPtr) override;
31946     }; // Inst_VOPC__V_CMPX_NE_U64
31947
31948     class Inst_VOPC__V_CMPX_GE_U64 : public Inst_VOPC
31949     {
31950       public:
31951         Inst_VOPC__V_CMPX_GE_U64(InFmt_VOPC*);
31952         ~Inst_VOPC__V_CMPX_GE_U64();
31953
31954         int
31955         getNumOperands() override
31956         {
31957             return numDstRegOperands() + numSrcRegOperands();
31958         } // getNumOperands
31959
31960         int numDstRegOperands() override { return 1; }
31961         int numSrcRegOperands() override { return 2; }
31962
31963         int
31964         getOperandSize(int opIdx) override
31965         {
31966             switch (opIdx) {
31967               case 0: //src_0
31968                 return 8;
31969               case 1: //src_1
31970                 return 8;
31971               case 2: //vcc
31972                 return 8;
31973               default:
31974                 fatal("op idx %i out of bounds\n", opIdx);
31975                 return -1;
31976             }
31977         } // getOperandSize
31978
31979         bool
31980         isSrcOperand(int opIdx) override
31981         {
31982             switch (opIdx) {
31983               case 0: //src_0
31984                 return true;
31985               case 1: //src_1
31986                 return true;
31987               default:
31988                 fatal("op idx %i out of bounds\n", opIdx);
31989                 return false;
31990             }
31991         } // isSrcOperand
31992
31993         bool
31994         isDstOperand(int opIdx) override
31995         {
31996             switch (opIdx) {
31997               case 0: //src_0
31998                 return false;
31999               case 1: //src_1
32000                 return false;
32001               default:
32002                 fatal("op idx %i out of bounds\n", opIdx);
32003                 return false;
32004             }
32005         } // isDstOperand
32006
32007         void execute(GPUDynInstPtr) override;
32008     }; // Inst_VOPC__V_CMPX_GE_U64
32009
32010     class Inst_VOPC__V_CMPX_T_U64 : public Inst_VOPC
32011     {
32012       public:
32013         Inst_VOPC__V_CMPX_T_U64(InFmt_VOPC*);
32014         ~Inst_VOPC__V_CMPX_T_U64();
32015
32016         int
32017         getNumOperands() override
32018         {
32019             return numDstRegOperands() + numSrcRegOperands();
32020         } // getNumOperands
32021
32022         int numDstRegOperands() override { return 1; }
32023         int numSrcRegOperands() override { return 2; }
32024
32025         int
32026         getOperandSize(int opIdx) override
32027         {
32028             switch (opIdx) {
32029               case 0: //src_0
32030                 return 8;
32031               case 1: //src_1
32032                 return 8;
32033               case 2: //vcc
32034                 return 8;
32035               default:
32036                 fatal("op idx %i out of bounds\n", opIdx);
32037                 return -1;
32038             }
32039         } // getOperandSize
32040
32041         bool
32042         isSrcOperand(int opIdx) override
32043         {
32044             switch (opIdx) {
32045               case 0: //src_0
32046                 return true;
32047               case 1: //src_1
32048                 return true;
32049               default:
32050                 fatal("op idx %i out of bounds\n", opIdx);
32051                 return false;
32052             }
32053         } // isSrcOperand
32054
32055         bool
32056         isDstOperand(int opIdx) override
32057         {
32058             switch (opIdx) {
32059               case 0: //src_0
32060                 return false;
32061               case 1: //src_1
32062                 return false;
32063               default:
32064                 fatal("op idx %i out of bounds\n", opIdx);
32065                 return false;
32066             }
32067         } // isDstOperand
32068
32069         void execute(GPUDynInstPtr) override;
32070     }; // Inst_VOPC__V_CMPX_T_U64
32071
32072     class Inst_VINTRP__V_INTERP_P1_F32 : public Inst_VINTRP
32073     {
32074       public:
32075         Inst_VINTRP__V_INTERP_P1_F32(InFmt_VINTRP*);
32076         ~Inst_VINTRP__V_INTERP_P1_F32();
32077
32078         int
32079         getNumOperands() override
32080         {
32081             return numDstRegOperands() + numSrcRegOperands();
32082         } // getNumOperands
32083
32084         int numDstRegOperands() override { return 1; }
32085         int numSrcRegOperands() override { return 2; }
32086
32087         int
32088         getOperandSize(int opIdx) override
32089         {
32090             switch (opIdx) {
32091               case 0: //vgpr_ij
32092                 return 4;
32093               case 1: //attr
32094                 return 16;
32095               case 2: //vgpr_dst
32096                 return 4;
32097               default:
32098                 fatal("op idx %i out of bounds\n", opIdx);
32099                 return -1;
32100             }
32101         } // getOperandSize
32102
32103         bool
32104         isSrcOperand(int opIdx) override
32105         {
32106             switch (opIdx) {
32107               case 0: //vgpr_ij
32108                 return true;
32109               case 1: //attr
32110                 return true;
32111               case 2: //vgpr_dst
32112                 return false;
32113               default:
32114                 fatal("op idx %i out of bounds\n", opIdx);
32115                 return false;
32116             }
32117         } // isSrcOperand
32118
32119         bool
32120         isDstOperand(int opIdx) override
32121         {
32122             switch (opIdx) {
32123               case 0: //vgpr_ij
32124                 return false;
32125               case 1: //attr
32126                 return false;
32127               case 2: //vgpr_dst
32128                 return true;
32129               default:
32130                 fatal("op idx %i out of bounds\n", opIdx);
32131                 return false;
32132             }
32133         } // isDstOperand
32134
32135         void execute(GPUDynInstPtr) override;
32136     }; // Inst_VINTRP__V_INTERP_P1_F32
32137
32138     class Inst_VINTRP__V_INTERP_P2_F32 : public Inst_VINTRP
32139     {
32140       public:
32141         Inst_VINTRP__V_INTERP_P2_F32(InFmt_VINTRP*);
32142         ~Inst_VINTRP__V_INTERP_P2_F32();
32143
32144         int
32145         getNumOperands() override
32146         {
32147             return numDstRegOperands() + numSrcRegOperands();
32148         } // getNumOperands
32149
32150         int numDstRegOperands() override { return 1; }
32151         int numSrcRegOperands() override { return 2; }
32152
32153         int
32154         getOperandSize(int opIdx) override
32155         {
32156             switch (opIdx) {
32157               case 0: //vgpr_ij
32158                 return 4;
32159               case 1: //attr
32160                 return 16;
32161               case 2: //vgpr_dst
32162                 return 4;
32163               default:
32164                 fatal("op idx %i out of bounds\n", opIdx);
32165                 return -1;
32166             }
32167         } // getOperandSize
32168
32169         bool
32170         isSrcOperand(int opIdx) override
32171         {
32172             switch (opIdx) {
32173               case 0: //vgpr_ij
32174                 return true;
32175               case 1: //attr
32176                 return true;
32177               case 2: //vgpr_dst
32178                 return false;
32179               default:
32180                 fatal("op idx %i out of bounds\n", opIdx);
32181                 return false;
32182             }
32183         } // isSrcOperand
32184
32185         bool
32186         isDstOperand(int opIdx) override
32187         {
32188             switch (opIdx) {
32189               case 0: //vgpr_ij
32190                 return false;
32191               case 1: //attr
32192                 return false;
32193               case 2: //vgpr_dst
32194                 return true;
32195               default:
32196                 fatal("op idx %i out of bounds\n", opIdx);
32197                 return false;
32198             }
32199         } // isDstOperand
32200
32201         void execute(GPUDynInstPtr) override;
32202     }; // Inst_VINTRP__V_INTERP_P2_F32
32203
32204     class Inst_VINTRP__V_INTERP_MOV_F32 : public Inst_VINTRP
32205     {
32206       public:
32207         Inst_VINTRP__V_INTERP_MOV_F32(InFmt_VINTRP*);
32208         ~Inst_VINTRP__V_INTERP_MOV_F32();
32209
32210         int
32211         getNumOperands() override
32212         {
32213             return numDstRegOperands() + numSrcRegOperands();
32214         } // getNumOperands
32215
32216         int numDstRegOperands() override { return 1; }
32217         int numSrcRegOperands() override { return 2; }
32218
32219         int
32220         getOperandSize(int opIdx) override
32221         {
32222             switch (opIdx) {
32223               case 0: //param
32224                 return 4;
32225               case 1: //attr
32226                 return 16;
32227               case 2: //vgpr_dst
32228                 return 4;
32229               default:
32230                 fatal("op idx %i out of bounds\n", opIdx);
32231                 return -1;
32232             }
32233         } // getOperandSize
32234
32235         bool
32236         isSrcOperand(int opIdx) override
32237         {
32238             switch (opIdx) {
32239               case 0: //param
32240                 return true;
32241               case 1: //attr
32242                 return true;
32243               case 2: //vgpr_dst
32244                 return false;
32245               default:
32246                 fatal("op idx %i out of bounds\n", opIdx);
32247                 return false;
32248             }
32249         } // isSrcOperand
32250
32251         bool
32252         isDstOperand(int opIdx) override
32253         {
32254             switch (opIdx) {
32255               case 0: //param
32256                 return false;
32257               case 1: //attr
32258                 return false;
32259               case 2: //vgpr_dst
32260                 return true;
32261               default:
32262                 fatal("op idx %i out of bounds\n", opIdx);
32263                 return false;
32264             }
32265         } // isDstOperand
32266
32267         void execute(GPUDynInstPtr) override;
32268     }; // Inst_VINTRP__V_INTERP_MOV_F32
32269
32270     class Inst_VOP3__V_CMP_CLASS_F32 : public Inst_VOP3
32271     {
32272       public:
32273         Inst_VOP3__V_CMP_CLASS_F32(InFmt_VOP3*);
32274         ~Inst_VOP3__V_CMP_CLASS_F32();
32275
32276         int
32277         getNumOperands() override
32278         {
32279             return numDstRegOperands() + numSrcRegOperands();
32280         } // getNumOperands
32281
32282         int numDstRegOperands() override { return 1; }
32283         int numSrcRegOperands() override { return 2; }
32284
32285         int
32286         getOperandSize(int opIdx) override
32287         {
32288             switch (opIdx) {
32289               case 0: //src_0
32290                 return 4;
32291               case 1: //src_1
32292                 return 4;
32293               case 2: //sdst
32294                 return 8;
32295               default:
32296                 fatal("op idx %i out of bounds\n", opIdx);
32297                 return -1;
32298             }
32299         } // getOperandSize
32300
32301         bool
32302         isSrcOperand(int opIdx) override
32303         {
32304             switch (opIdx) {
32305               case 0: //src_0
32306                 return true;
32307               case 1: //src_1
32308                 return true;
32309               case 2: //sdst
32310                 return false;
32311               default:
32312                 fatal("op idx %i out of bounds\n", opIdx);
32313                 return false;
32314             }
32315         } // isSrcOperand
32316
32317         bool
32318         isDstOperand(int opIdx) override
32319         {
32320             switch (opIdx) {
32321               case 0: //src_0
32322                 return false;
32323               case 1: //src_1
32324                 return false;
32325               case 2: //sdst
32326                 return true;
32327               default:
32328                 fatal("op idx %i out of bounds\n", opIdx);
32329                 return false;
32330             }
32331         } // isDstOperand
32332
32333         void execute(GPUDynInstPtr) override;
32334     }; // Inst_VOP3__V_CMP_CLASS_F32
32335
32336     class Inst_VOP3__V_CMPX_CLASS_F32 : public Inst_VOP3
32337     {
32338       public:
32339         Inst_VOP3__V_CMPX_CLASS_F32(InFmt_VOP3*);
32340         ~Inst_VOP3__V_CMPX_CLASS_F32();
32341
32342         int
32343         getNumOperands() override
32344         {
32345             return numDstRegOperands() + numSrcRegOperands();
32346         } // getNumOperands
32347
32348         int numDstRegOperands() override { return 1; }
32349         int numSrcRegOperands() override { return 2; }
32350
32351         int
32352         getOperandSize(int opIdx) override
32353         {
32354             switch (opIdx) {
32355               case 0: //src_0
32356                 return 4;
32357               case 1: //src_1
32358                 return 4;
32359               case 2: //sdst
32360                 return 8;
32361               default:
32362                 fatal("op idx %i out of bounds\n", opIdx);
32363                 return -1;
32364             }
32365         } // getOperandSize
32366
32367         bool
32368         isSrcOperand(int opIdx) override
32369         {
32370             switch (opIdx) {
32371               case 0: //src_0
32372                 return true;
32373               case 1: //src_1
32374                 return true;
32375               case 2: //sdst
32376                 return false;
32377               default:
32378                 fatal("op idx %i out of bounds\n", opIdx);
32379                 return false;
32380             }
32381         } // isSrcOperand
32382
32383         bool
32384         isDstOperand(int opIdx) override
32385         {
32386             switch (opIdx) {
32387               case 0: //src_0
32388                 return false;
32389               case 1: //src_1
32390                 return false;
32391               case 2: //sdst
32392                 return true;
32393               default:
32394                 fatal("op idx %i out of bounds\n", opIdx);
32395                 return false;
32396             }
32397         } // isDstOperand
32398
32399         void execute(GPUDynInstPtr) override;
32400     }; // Inst_VOP3__V_CMPX_CLASS_F32
32401
32402     class Inst_VOP3__V_CMP_CLASS_F64 : public Inst_VOP3
32403     {
32404       public:
32405         Inst_VOP3__V_CMP_CLASS_F64(InFmt_VOP3*);
32406         ~Inst_VOP3__V_CMP_CLASS_F64();
32407
32408         int
32409         getNumOperands() override
32410         {
32411             return numDstRegOperands() + numSrcRegOperands();
32412         } // getNumOperands
32413
32414         int numDstRegOperands() override { return 1; }
32415         int numSrcRegOperands() override { return 2; }
32416
32417         int
32418         getOperandSize(int opIdx) override
32419         {
32420             switch (opIdx) {
32421               case 0: //src_0
32422                 return 8;
32423               case 1: //src_1
32424                 return 4;
32425               case 2: //sdst
32426                 return 8;
32427               default:
32428                 fatal("op idx %i out of bounds\n", opIdx);
32429                 return -1;
32430             }
32431         } // getOperandSize
32432
32433         bool
32434         isSrcOperand(int opIdx) override
32435         {
32436             switch (opIdx) {
32437               case 0: //src_0
32438                 return true;
32439               case 1: //src_1
32440                 return true;
32441               case 2: //sdst
32442                 return false;
32443               default:
32444                 fatal("op idx %i out of bounds\n", opIdx);
32445                 return false;
32446             }
32447         } // isSrcOperand
32448
32449         bool
32450         isDstOperand(int opIdx) override
32451         {
32452             switch (opIdx) {
32453               case 0: //src_0
32454                 return false;
32455               case 1: //src_1
32456                 return false;
32457               case 2: //sdst
32458                 return true;
32459               default:
32460                 fatal("op idx %i out of bounds\n", opIdx);
32461                 return false;
32462             }
32463         } // isDstOperand
32464
32465         void execute(GPUDynInstPtr) override;
32466     }; // Inst_VOP3__V_CMP_CLASS_F64
32467
32468     class Inst_VOP3__V_CMPX_CLASS_F64 : public Inst_VOP3
32469     {
32470       public:
32471         Inst_VOP3__V_CMPX_CLASS_F64(InFmt_VOP3*);
32472         ~Inst_VOP3__V_CMPX_CLASS_F64();
32473
32474         int
32475         getNumOperands() override
32476         {
32477             return numDstRegOperands() + numSrcRegOperands();
32478         } // getNumOperands
32479
32480         int numDstRegOperands() override { return 1; }
32481         int numSrcRegOperands() override { return 2; }
32482
32483         int
32484         getOperandSize(int opIdx) override
32485         {
32486             switch (opIdx) {
32487               case 0: //src_0
32488                 return 8;
32489               case 1: //src_1
32490                 return 4;
32491               case 2: //sdst
32492                 return 8;
32493               default:
32494                 fatal("op idx %i out of bounds\n", opIdx);
32495                 return -1;
32496             }
32497         } // getOperandSize
32498
32499         bool
32500         isSrcOperand(int opIdx) override
32501         {
32502             switch (opIdx) {
32503               case 0: //src_0
32504                 return true;
32505               case 1: //src_1
32506                 return true;
32507               case 2: //sdst
32508                 return false;
32509               default:
32510                 fatal("op idx %i out of bounds\n", opIdx);
32511                 return false;
32512             }
32513         } // isSrcOperand
32514
32515         bool
32516         isDstOperand(int opIdx) override
32517         {
32518             switch (opIdx) {
32519               case 0: //src_0
32520                 return false;
32521               case 1: //src_1
32522                 return false;
32523               case 2: //sdst
32524                 return true;
32525               default:
32526                 fatal("op idx %i out of bounds\n", opIdx);
32527                 return false;
32528             }
32529         } // isDstOperand
32530
32531         void execute(GPUDynInstPtr) override;
32532     }; // Inst_VOP3__V_CMPX_CLASS_F64
32533
32534     class Inst_VOP3__V_CMP_CLASS_F16 : public Inst_VOP3
32535     {
32536       public:
32537         Inst_VOP3__V_CMP_CLASS_F16(InFmt_VOP3*);
32538         ~Inst_VOP3__V_CMP_CLASS_F16();
32539
32540         int
32541         getNumOperands() override
32542         {
32543             return numDstRegOperands() + numSrcRegOperands();
32544         } // getNumOperands
32545
32546         int numDstRegOperands() override { return 1; }
32547         int numSrcRegOperands() override { return 2; }
32548
32549         int
32550         getOperandSize(int opIdx) override
32551         {
32552             switch (opIdx) {
32553               case 0: //src_0
32554                 return 2;
32555               case 1: //src_1
32556                 return 2;
32557               case 2: //sdst
32558                 return 8;
32559               default:
32560                 fatal("op idx %i out of bounds\n", opIdx);
32561                 return -1;
32562             }
32563         } // getOperandSize
32564
32565         bool
32566         isSrcOperand(int opIdx) override
32567         {
32568             switch (opIdx) {
32569               case 0: //src_0
32570                 return true;
32571               case 1: //src_1
32572                 return true;
32573               case 2: //sdst
32574                 return false;
32575               default:
32576                 fatal("op idx %i out of bounds\n", opIdx);
32577                 return false;
32578             }
32579         } // isSrcOperand
32580
32581         bool
32582         isDstOperand(int opIdx) override
32583         {
32584             switch (opIdx) {
32585               case 0: //src_0
32586                 return false;
32587               case 1: //src_1
32588                 return false;
32589               case 2: //sdst
32590                 return true;
32591               default:
32592                 fatal("op idx %i out of bounds\n", opIdx);
32593                 return false;
32594             }
32595         } // isDstOperand
32596
32597         void execute(GPUDynInstPtr) override;
32598     }; // Inst_VOP3__V_CMP_CLASS_F16
32599
32600     class Inst_VOP3__V_CMPX_CLASS_F16 : public Inst_VOP3
32601     {
32602       public:
32603         Inst_VOP3__V_CMPX_CLASS_F16(InFmt_VOP3*);
32604         ~Inst_VOP3__V_CMPX_CLASS_F16();
32605
32606         int
32607         getNumOperands() override
32608         {
32609             return numDstRegOperands() + numSrcRegOperands();
32610         } // getNumOperands
32611
32612         int numDstRegOperands() override { return 1; }
32613         int numSrcRegOperands() override { return 2; }
32614
32615         int
32616         getOperandSize(int opIdx) override
32617         {
32618             switch (opIdx) {
32619               case 0: //src_0
32620                 return 2;
32621               case 1: //src_1
32622                 return 2;
32623               case 2: //sdst
32624                 return 8;
32625               default:
32626                 fatal("op idx %i out of bounds\n", opIdx);
32627                 return -1;
32628             }
32629         } // getOperandSize
32630
32631         bool
32632         isSrcOperand(int opIdx) override
32633         {
32634             switch (opIdx) {
32635               case 0: //src_0
32636                 return true;
32637               case 1: //src_1
32638                 return true;
32639               case 2: //sdst
32640                 return false;
32641               default:
32642                 fatal("op idx %i out of bounds\n", opIdx);
32643                 return false;
32644             }
32645         } // isSrcOperand
32646
32647         bool
32648         isDstOperand(int opIdx) override
32649         {
32650             switch (opIdx) {
32651               case 0: //src_0
32652                 return false;
32653               case 1: //src_1
32654                 return false;
32655               case 2: //sdst
32656                 return true;
32657               default:
32658                 fatal("op idx %i out of bounds\n", opIdx);
32659                 return false;
32660             }
32661         } // isDstOperand
32662
32663         void execute(GPUDynInstPtr) override;
32664     }; // Inst_VOP3__V_CMPX_CLASS_F16
32665
32666     class Inst_VOP3__V_CMP_F_F16 : public Inst_VOP3
32667     {
32668       public:
32669         Inst_VOP3__V_CMP_F_F16(InFmt_VOP3*);
32670         ~Inst_VOP3__V_CMP_F_F16();
32671
32672         int
32673         getNumOperands() override
32674         {
32675             return numDstRegOperands() + numSrcRegOperands();
32676         } // getNumOperands
32677
32678         int numDstRegOperands() override { return 1; }
32679         int numSrcRegOperands() override { return 2; }
32680
32681         int
32682         getOperandSize(int opIdx) override
32683         {
32684             switch (opIdx) {
32685               case 0: //src_0
32686                 return 2;
32687               case 1: //src_1
32688                 return 2;
32689               case 2: //sdst
32690                 return 8;
32691               default:
32692                 fatal("op idx %i out of bounds\n", opIdx);
32693                 return -1;
32694             }
32695         } // getOperandSize
32696
32697         bool
32698         isSrcOperand(int opIdx) override
32699         {
32700             switch (opIdx) {
32701               case 0: //src_0
32702                 return true;
32703               case 1: //src_1
32704                 return true;
32705               case 2: //sdst
32706                 return false;
32707               default:
32708                 fatal("op idx %i out of bounds\n", opIdx);
32709                 return false;
32710             }
32711         } // isSrcOperand
32712
32713         bool
32714         isDstOperand(int opIdx) override
32715         {
32716             switch (opIdx) {
32717               case 0: //src_0
32718                 return false;
32719               case 1: //src_1
32720                 return false;
32721               case 2: //sdst
32722                 return true;
32723               default:
32724                 fatal("op idx %i out of bounds\n", opIdx);
32725                 return false;
32726             }
32727         } // isDstOperand
32728
32729         void execute(GPUDynInstPtr) override;
32730     }; // Inst_VOP3__V_CMP_F_F16
32731
32732     class Inst_VOP3__V_CMP_LT_F16 : public Inst_VOP3
32733     {
32734       public:
32735         Inst_VOP3__V_CMP_LT_F16(InFmt_VOP3*);
32736         ~Inst_VOP3__V_CMP_LT_F16();
32737
32738         int
32739         getNumOperands() override
32740         {
32741             return numDstRegOperands() + numSrcRegOperands();
32742         } // getNumOperands
32743
32744         int numDstRegOperands() override { return 1; }
32745         int numSrcRegOperands() override { return 2; }
32746
32747         int
32748         getOperandSize(int opIdx) override
32749         {
32750             switch (opIdx) {
32751               case 0: //src_0
32752                 return 2;
32753               case 1: //src_1
32754                 return 2;
32755               case 2: //sdst
32756                 return 8;
32757               default:
32758                 fatal("op idx %i out of bounds\n", opIdx);
32759                 return -1;
32760             }
32761         } // getOperandSize
32762
32763         bool
32764         isSrcOperand(int opIdx) override
32765         {
32766             switch (opIdx) {
32767               case 0: //src_0
32768                 return true;
32769               case 1: //src_1
32770                 return true;
32771               case 2: //sdst
32772                 return false;
32773               default:
32774                 fatal("op idx %i out of bounds\n", opIdx);
32775                 return false;
32776             }
32777         } // isSrcOperand
32778
32779         bool
32780         isDstOperand(int opIdx) override
32781         {
32782             switch (opIdx) {
32783               case 0: //src_0
32784                 return false;
32785               case 1: //src_1
32786                 return false;
32787               case 2: //sdst
32788                 return true;
32789               default:
32790                 fatal("op idx %i out of bounds\n", opIdx);
32791                 return false;
32792             }
32793         } // isDstOperand
32794
32795         void execute(GPUDynInstPtr) override;
32796     }; // Inst_VOP3__V_CMP_LT_F16
32797
32798     class Inst_VOP3__V_CMP_EQ_F16 : public Inst_VOP3
32799     {
32800       public:
32801         Inst_VOP3__V_CMP_EQ_F16(InFmt_VOP3*);
32802         ~Inst_VOP3__V_CMP_EQ_F16();
32803
32804         int
32805         getNumOperands() override
32806         {
32807             return numDstRegOperands() + numSrcRegOperands();
32808         } // getNumOperands
32809
32810         int numDstRegOperands() override { return 1; }
32811         int numSrcRegOperands() override { return 2; }
32812
32813         int
32814         getOperandSize(int opIdx) override
32815         {
32816             switch (opIdx) {
32817               case 0: //src_0
32818                 return 2;
32819               case 1: //src_1
32820                 return 2;
32821               case 2: //sdst
32822                 return 8;
32823               default:
32824                 fatal("op idx %i out of bounds\n", opIdx);
32825                 return -1;
32826             }
32827         } // getOperandSize
32828
32829         bool
32830         isSrcOperand(int opIdx) override
32831         {
32832             switch (opIdx) {
32833               case 0: //src_0
32834                 return true;
32835               case 1: //src_1
32836                 return true;
32837               case 2: //sdst
32838                 return false;
32839               default:
32840                 fatal("op idx %i out of bounds\n", opIdx);
32841                 return false;
32842             }
32843         } // isSrcOperand
32844
32845         bool
32846         isDstOperand(int opIdx) override
32847         {
32848             switch (opIdx) {
32849               case 0: //src_0
32850                 return false;
32851               case 1: //src_1
32852                 return false;
32853               case 2: //sdst
32854                 return true;
32855               default:
32856                 fatal("op idx %i out of bounds\n", opIdx);
32857                 return false;
32858             }
32859         } // isDstOperand
32860
32861         void execute(GPUDynInstPtr) override;
32862     }; // Inst_VOP3__V_CMP_EQ_F16
32863
32864     class Inst_VOP3__V_CMP_LE_F16 : public Inst_VOP3
32865     {
32866       public:
32867         Inst_VOP3__V_CMP_LE_F16(InFmt_VOP3*);
32868         ~Inst_VOP3__V_CMP_LE_F16();
32869
32870         int
32871         getNumOperands() override
32872         {
32873             return numDstRegOperands() + numSrcRegOperands();
32874         } // getNumOperands
32875
32876         int numDstRegOperands() override { return 1; }
32877         int numSrcRegOperands() override { return 2; }
32878
32879         int
32880         getOperandSize(int opIdx) override
32881         {
32882             switch (opIdx) {
32883               case 0: //src_0
32884                 return 2;
32885               case 1: //src_1
32886                 return 2;
32887               case 2: //sdst
32888                 return 8;
32889               default:
32890                 fatal("op idx %i out of bounds\n", opIdx);
32891                 return -1;
32892             }
32893         } // getOperandSize
32894
32895         bool
32896         isSrcOperand(int opIdx) override
32897         {
32898             switch (opIdx) {
32899               case 0: //src_0
32900                 return true;
32901               case 1: //src_1
32902                 return true;
32903               case 2: //sdst
32904                 return false;
32905               default:
32906                 fatal("op idx %i out of bounds\n", opIdx);
32907                 return false;
32908             }
32909         } // isSrcOperand
32910
32911         bool
32912         isDstOperand(int opIdx) override
32913         {
32914             switch (opIdx) {
32915               case 0: //src_0
32916                 return false;
32917               case 1: //src_1
32918                 return false;
32919               case 2: //sdst
32920                 return true;
32921               default:
32922                 fatal("op idx %i out of bounds\n", opIdx);
32923                 return false;
32924             }
32925         } // isDstOperand
32926
32927         void execute(GPUDynInstPtr) override;
32928     }; // Inst_VOP3__V_CMP_LE_F16
32929
32930     class Inst_VOP3__V_CMP_GT_F16 : public Inst_VOP3
32931     {
32932       public:
32933         Inst_VOP3__V_CMP_GT_F16(InFmt_VOP3*);
32934         ~Inst_VOP3__V_CMP_GT_F16();
32935
32936         int
32937         getNumOperands() override
32938         {
32939             return numDstRegOperands() + numSrcRegOperands();
32940         } // getNumOperands
32941
32942         int numDstRegOperands() override { return 1; }
32943         int numSrcRegOperands() override { return 2; }
32944
32945         int
32946         getOperandSize(int opIdx) override
32947         {
32948             switch (opIdx) {
32949               case 0: //src_0
32950                 return 2;
32951               case 1: //src_1
32952                 return 2;
32953               case 2: //sdst
32954                 return 8;
32955               default:
32956                 fatal("op idx %i out of bounds\n", opIdx);
32957                 return -1;
32958             }
32959         } // getOperandSize
32960
32961         bool
32962         isSrcOperand(int opIdx) override
32963         {
32964             switch (opIdx) {
32965               case 0: //src_0
32966                 return true;
32967               case 1: //src_1
32968                 return true;
32969               case 2: //sdst
32970                 return false;
32971               default:
32972                 fatal("op idx %i out of bounds\n", opIdx);
32973                 return false;
32974             }
32975         } // isSrcOperand
32976
32977         bool
32978         isDstOperand(int opIdx) override
32979         {
32980             switch (opIdx) {
32981               case 0: //src_0
32982                 return false;
32983               case 1: //src_1
32984                 return false;
32985               case 2: //sdst
32986                 return true;
32987               default:
32988                 fatal("op idx %i out of bounds\n", opIdx);
32989                 return false;
32990             }
32991         } // isDstOperand
32992
32993         void execute(GPUDynInstPtr) override;
32994     }; // Inst_VOP3__V_CMP_GT_F16
32995
32996     class Inst_VOP3__V_CMP_LG_F16 : public Inst_VOP3
32997     {
32998       public:
32999         Inst_VOP3__V_CMP_LG_F16(InFmt_VOP3*);
33000         ~Inst_VOP3__V_CMP_LG_F16();
33001
33002         int
33003         getNumOperands() override
33004         {
33005             return numDstRegOperands() + numSrcRegOperands();
33006         } // getNumOperands
33007
33008         int numDstRegOperands() override { return 1; }
33009         int numSrcRegOperands() override { return 2; }
33010
33011         int
33012         getOperandSize(int opIdx) override
33013         {
33014             switch (opIdx) {
33015               case 0: //src_0
33016                 return 2;
33017               case 1: //src_1
33018                 return 2;
33019               case 2: //sdst
33020                 return 8;
33021               default:
33022                 fatal("op idx %i out of bounds\n", opIdx);
33023                 return -1;
33024             }
33025         } // getOperandSize
33026
33027         bool
33028         isSrcOperand(int opIdx) override
33029         {
33030             switch (opIdx) {
33031               case 0: //src_0
33032                 return true;
33033               case 1: //src_1
33034                 return true;
33035               case 2: //sdst
33036                 return false;
33037               default:
33038                 fatal("op idx %i out of bounds\n", opIdx);
33039                 return false;
33040             }
33041         } // isSrcOperand
33042
33043         bool
33044         isDstOperand(int opIdx) override
33045         {
33046             switch (opIdx) {
33047               case 0: //src_0
33048                 return false;
33049               case 1: //src_1
33050                 return false;
33051               case 2: //sdst
33052                 return true;
33053               default:
33054                 fatal("op idx %i out of bounds\n", opIdx);
33055                 return false;
33056             }
33057         } // isDstOperand
33058
33059         void execute(GPUDynInstPtr) override;
33060     }; // Inst_VOP3__V_CMP_LG_F16
33061
33062     class Inst_VOP3__V_CMP_GE_F16 : public Inst_VOP3
33063     {
33064       public:
33065         Inst_VOP3__V_CMP_GE_F16(InFmt_VOP3*);
33066         ~Inst_VOP3__V_CMP_GE_F16();
33067
33068         int
33069         getNumOperands() override
33070         {
33071             return numDstRegOperands() + numSrcRegOperands();
33072         } // getNumOperands
33073
33074         int numDstRegOperands() override { return 1; }
33075         int numSrcRegOperands() override { return 2; }
33076
33077         int
33078         getOperandSize(int opIdx) override
33079         {
33080             switch (opIdx) {
33081               case 0: //src_0
33082                 return 2;
33083               case 1: //src_1
33084                 return 2;
33085               case 2: //sdst
33086                 return 8;
33087               default:
33088                 fatal("op idx %i out of bounds\n", opIdx);
33089                 return -1;
33090             }
33091         } // getOperandSize
33092
33093         bool
33094         isSrcOperand(int opIdx) override
33095         {
33096             switch (opIdx) {
33097               case 0: //src_0
33098                 return true;
33099               case 1: //src_1
33100                 return true;
33101               case 2: //sdst
33102                 return false;
33103               default:
33104                 fatal("op idx %i out of bounds\n", opIdx);
33105                 return false;
33106             }
33107         } // isSrcOperand
33108
33109         bool
33110         isDstOperand(int opIdx) override
33111         {
33112             switch (opIdx) {
33113               case 0: //src_0
33114                 return false;
33115               case 1: //src_1
33116                 return false;
33117               case 2: //sdst
33118                 return true;
33119               default:
33120                 fatal("op idx %i out of bounds\n", opIdx);
33121                 return false;
33122             }
33123         } // isDstOperand
33124
33125         void execute(GPUDynInstPtr) override;
33126     }; // Inst_VOP3__V_CMP_GE_F16
33127
33128     class Inst_VOP3__V_CMP_O_F16 : public Inst_VOP3
33129     {
33130       public:
33131         Inst_VOP3__V_CMP_O_F16(InFmt_VOP3*);
33132         ~Inst_VOP3__V_CMP_O_F16();
33133
33134         int
33135         getNumOperands() override
33136         {
33137             return numDstRegOperands() + numSrcRegOperands();
33138         } // getNumOperands
33139
33140         int numDstRegOperands() override { return 1; }
33141         int numSrcRegOperands() override { return 2; }
33142
33143         int
33144         getOperandSize(int opIdx) override
33145         {
33146             switch (opIdx) {
33147               case 0: //src_0
33148                 return 2;
33149               case 1: //src_1
33150                 return 2;
33151               case 2: //sdst
33152                 return 8;
33153               default:
33154                 fatal("op idx %i out of bounds\n", opIdx);
33155                 return -1;
33156             }
33157         } // getOperandSize
33158
33159         bool
33160         isSrcOperand(int opIdx) override
33161         {
33162             switch (opIdx) {
33163               case 0: //src_0
33164                 return true;
33165               case 1: //src_1
33166                 return true;
33167               case 2: //sdst
33168                 return false;
33169               default:
33170                 fatal("op idx %i out of bounds\n", opIdx);
33171                 return false;
33172             }
33173         } // isSrcOperand
33174
33175         bool
33176         isDstOperand(int opIdx) override
33177         {
33178             switch (opIdx) {
33179               case 0: //src_0
33180                 return false;
33181               case 1: //src_1
33182                 return false;
33183               case 2: //sdst
33184                 return true;
33185               default:
33186                 fatal("op idx %i out of bounds\n", opIdx);
33187                 return false;
33188             }
33189         } // isDstOperand
33190
33191         void execute(GPUDynInstPtr) override;
33192     }; // Inst_VOP3__V_CMP_O_F16
33193
33194     class Inst_VOP3__V_CMP_U_F16 : public Inst_VOP3
33195     {
33196       public:
33197         Inst_VOP3__V_CMP_U_F16(InFmt_VOP3*);
33198         ~Inst_VOP3__V_CMP_U_F16();
33199
33200         int
33201         getNumOperands() override
33202         {
33203             return numDstRegOperands() + numSrcRegOperands();
33204         } // getNumOperands
33205
33206         int numDstRegOperands() override { return 1; }
33207         int numSrcRegOperands() override { return 2; }
33208
33209         int
33210         getOperandSize(int opIdx) override
33211         {
33212             switch (opIdx) {
33213               case 0: //src_0
33214                 return 2;
33215               case 1: //src_1
33216                 return 2;
33217               case 2: //sdst
33218                 return 8;
33219               default:
33220                 fatal("op idx %i out of bounds\n", opIdx);
33221                 return -1;
33222             }
33223         } // getOperandSize
33224
33225         bool
33226         isSrcOperand(int opIdx) override
33227         {
33228             switch (opIdx) {
33229               case 0: //src_0
33230                 return true;
33231               case 1: //src_1
33232                 return true;
33233               case 2: //sdst
33234                 return false;
33235               default:
33236                 fatal("op idx %i out of bounds\n", opIdx);
33237                 return false;
33238             }
33239         } // isSrcOperand
33240
33241         bool
33242         isDstOperand(int opIdx) override
33243         {
33244             switch (opIdx) {
33245               case 0: //src_0
33246                 return false;
33247               case 1: //src_1
33248                 return false;
33249               case 2: //sdst
33250                 return true;
33251               default:
33252                 fatal("op idx %i out of bounds\n", opIdx);
33253                 return false;
33254             }
33255         } // isDstOperand
33256
33257         void execute(GPUDynInstPtr) override;
33258     }; // Inst_VOP3__V_CMP_U_F16
33259
33260     class Inst_VOP3__V_CMP_NGE_F16 : public Inst_VOP3
33261     {
33262       public:
33263         Inst_VOP3__V_CMP_NGE_F16(InFmt_VOP3*);
33264         ~Inst_VOP3__V_CMP_NGE_F16();
33265
33266         int
33267         getNumOperands() override
33268         {
33269             return numDstRegOperands() + numSrcRegOperands();
33270         } // getNumOperands
33271
33272         int numDstRegOperands() override { return 1; }
33273         int numSrcRegOperands() override { return 2; }
33274
33275         int
33276         getOperandSize(int opIdx) override
33277         {
33278             switch (opIdx) {
33279               case 0: //src_0
33280                 return 2;
33281               case 1: //src_1
33282                 return 2;
33283               case 2: //sdst
33284                 return 8;
33285               default:
33286                 fatal("op idx %i out of bounds\n", opIdx);
33287                 return -1;
33288             }
33289         } // getOperandSize
33290
33291         bool
33292         isSrcOperand(int opIdx) override
33293         {
33294             switch (opIdx) {
33295               case 0: //src_0
33296                 return true;
33297               case 1: //src_1
33298                 return true;
33299               case 2: //sdst
33300                 return false;
33301               default:
33302                 fatal("op idx %i out of bounds\n", opIdx);
33303                 return false;
33304             }
33305         } // isSrcOperand
33306
33307         bool
33308         isDstOperand(int opIdx) override
33309         {
33310             switch (opIdx) {
33311               case 0: //src_0
33312                 return false;
33313               case 1: //src_1
33314                 return false;
33315               case 2: //sdst
33316                 return true;
33317               default:
33318                 fatal("op idx %i out of bounds\n", opIdx);
33319                 return false;
33320             }
33321         } // isDstOperand
33322
33323         void execute(GPUDynInstPtr) override;
33324     }; // Inst_VOP3__V_CMP_NGE_F16
33325
33326     class Inst_VOP3__V_CMP_NLG_F16 : public Inst_VOP3
33327     {
33328       public:
33329         Inst_VOP3__V_CMP_NLG_F16(InFmt_VOP3*);
33330         ~Inst_VOP3__V_CMP_NLG_F16();
33331
33332         int
33333         getNumOperands() override
33334         {
33335             return numDstRegOperands() + numSrcRegOperands();
33336         } // getNumOperands
33337
33338         int numDstRegOperands() override { return 1; }
33339         int numSrcRegOperands() override { return 2; }
33340
33341         int
33342         getOperandSize(int opIdx) override
33343         {
33344             switch (opIdx) {
33345               case 0: //src_0
33346                 return 2;
33347               case 1: //src_1
33348                 return 2;
33349               case 2: //sdst
33350                 return 8;
33351               default:
33352                 fatal("op idx %i out of bounds\n", opIdx);
33353                 return -1;
33354             }
33355         } // getOperandSize
33356
33357         bool
33358         isSrcOperand(int opIdx) override
33359         {
33360             switch (opIdx) {
33361               case 0: //src_0
33362                 return true;
33363               case 1: //src_1
33364                 return true;
33365               case 2: //sdst
33366                 return false;
33367               default:
33368                 fatal("op idx %i out of bounds\n", opIdx);
33369                 return false;
33370             }
33371         } // isSrcOperand
33372
33373         bool
33374         isDstOperand(int opIdx) override
33375         {
33376             switch (opIdx) {
33377               case 0: //src_0
33378                 return false;
33379               case 1: //src_1
33380                 return false;
33381               case 2: //sdst
33382                 return true;
33383               default:
33384                 fatal("op idx %i out of bounds\n", opIdx);
33385                 return false;
33386             }
33387         } // isDstOperand
33388
33389         void execute(GPUDynInstPtr) override;
33390     }; // Inst_VOP3__V_CMP_NLG_F16
33391
33392     class Inst_VOP3__V_CMP_NGT_F16 : public Inst_VOP3
33393     {
33394       public:
33395         Inst_VOP3__V_CMP_NGT_F16(InFmt_VOP3*);
33396         ~Inst_VOP3__V_CMP_NGT_F16();
33397
33398         int
33399         getNumOperands() override
33400         {
33401             return numDstRegOperands() + numSrcRegOperands();
33402         } // getNumOperands
33403
33404         int numDstRegOperands() override { return 1; }
33405         int numSrcRegOperands() override { return 2; }
33406
33407         int
33408         getOperandSize(int opIdx) override
33409         {
33410             switch (opIdx) {
33411               case 0: //src_0
33412                 return 2;
33413               case 1: //src_1
33414                 return 2;
33415               case 2: //sdst
33416                 return 8;
33417               default:
33418                 fatal("op idx %i out of bounds\n", opIdx);
33419                 return -1;
33420             }
33421         } // getOperandSize
33422
33423         bool
33424         isSrcOperand(int opIdx) override
33425         {
33426             switch (opIdx) {
33427               case 0: //src_0
33428                 return true;
33429               case 1: //src_1
33430                 return true;
33431               case 2: //sdst
33432                 return false;
33433               default:
33434                 fatal("op idx %i out of bounds\n", opIdx);
33435                 return false;
33436             }
33437         } // isSrcOperand
33438
33439         bool
33440         isDstOperand(int opIdx) override
33441         {
33442             switch (opIdx) {
33443               case 0: //src_0
33444                 return false;
33445               case 1: //src_1
33446                 return false;
33447               case 2: //sdst
33448                 return true;
33449               default:
33450                 fatal("op idx %i out of bounds\n", opIdx);
33451                 return false;
33452             }
33453         } // isDstOperand
33454
33455         void execute(GPUDynInstPtr) override;
33456     }; // Inst_VOP3__V_CMP_NGT_F16
33457
33458     class Inst_VOP3__V_CMP_NLE_F16 : public Inst_VOP3
33459     {
33460       public:
33461         Inst_VOP3__V_CMP_NLE_F16(InFmt_VOP3*);
33462         ~Inst_VOP3__V_CMP_NLE_F16();
33463
33464         int
33465         getNumOperands() override
33466         {
33467             return numDstRegOperands() + numSrcRegOperands();
33468         } // getNumOperands
33469
33470         int numDstRegOperands() override { return 1; }
33471         int numSrcRegOperands() override { return 2; }
33472
33473         int
33474         getOperandSize(int opIdx) override
33475         {
33476             switch (opIdx) {
33477               case 0: //src_0
33478                 return 2;
33479               case 1: //src_1
33480                 return 2;
33481               case 2: //sdst
33482                 return 8;
33483               default:
33484                 fatal("op idx %i out of bounds\n", opIdx);
33485                 return -1;
33486             }
33487         } // getOperandSize
33488
33489         bool
33490         isSrcOperand(int opIdx) override
33491         {
33492             switch (opIdx) {
33493               case 0: //src_0
33494                 return true;
33495               case 1: //src_1
33496                 return true;
33497               case 2: //sdst
33498                 return false;
33499               default:
33500                 fatal("op idx %i out of bounds\n", opIdx);
33501                 return false;
33502             }
33503         } // isSrcOperand
33504
33505         bool
33506         isDstOperand(int opIdx) override
33507         {
33508             switch (opIdx) {
33509               case 0: //src_0
33510                 return false;
33511               case 1: //src_1
33512                 return false;
33513               case 2: //sdst
33514                 return true;
33515               default:
33516                 fatal("op idx %i out of bounds\n", opIdx);
33517                 return false;
33518             }
33519         } // isDstOperand
33520
33521         void execute(GPUDynInstPtr) override;
33522     }; // Inst_VOP3__V_CMP_NLE_F16
33523
33524     class Inst_VOP3__V_CMP_NEQ_F16 : public Inst_VOP3
33525     {
33526       public:
33527         Inst_VOP3__V_CMP_NEQ_F16(InFmt_VOP3*);
33528         ~Inst_VOP3__V_CMP_NEQ_F16();
33529
33530         int
33531         getNumOperands() override
33532         {
33533             return numDstRegOperands() + numSrcRegOperands();
33534         } // getNumOperands
33535
33536         int numDstRegOperands() override { return 1; }
33537         int numSrcRegOperands() override { return 2; }
33538
33539         int
33540         getOperandSize(int opIdx) override
33541         {
33542             switch (opIdx) {
33543               case 0: //src_0
33544                 return 2;
33545               case 1: //src_1
33546                 return 2;
33547               case 2: //sdst
33548                 return 8;
33549               default:
33550                 fatal("op idx %i out of bounds\n", opIdx);
33551                 return -1;
33552             }
33553         } // getOperandSize
33554
33555         bool
33556         isSrcOperand(int opIdx) override
33557         {
33558             switch (opIdx) {
33559               case 0: //src_0
33560                 return true;
33561               case 1: //src_1
33562                 return true;
33563               case 2: //sdst
33564                 return false;
33565               default:
33566                 fatal("op idx %i out of bounds\n", opIdx);
33567                 return false;
33568             }
33569         } // isSrcOperand
33570
33571         bool
33572         isDstOperand(int opIdx) override
33573         {
33574             switch (opIdx) {
33575               case 0: //src_0
33576                 return false;
33577               case 1: //src_1
33578                 return false;
33579               case 2: //sdst
33580                 return true;
33581               default:
33582                 fatal("op idx %i out of bounds\n", opIdx);
33583                 return false;
33584             }
33585         } // isDstOperand
33586
33587         void execute(GPUDynInstPtr) override;
33588     }; // Inst_VOP3__V_CMP_NEQ_F16
33589
33590     class Inst_VOP3__V_CMP_NLT_F16 : public Inst_VOP3
33591     {
33592       public:
33593         Inst_VOP3__V_CMP_NLT_F16(InFmt_VOP3*);
33594         ~Inst_VOP3__V_CMP_NLT_F16();
33595
33596         int
33597         getNumOperands() override
33598         {
33599             return numDstRegOperands() + numSrcRegOperands();
33600         } // getNumOperands
33601
33602         int numDstRegOperands() override { return 1; }
33603         int numSrcRegOperands() override { return 2; }
33604
33605         int
33606         getOperandSize(int opIdx) override
33607         {
33608             switch (opIdx) {
33609               case 0: //src_0
33610                 return 2;
33611               case 1: //src_1
33612                 return 2;
33613               case 2: //sdst
33614                 return 8;
33615               default:
33616                 fatal("op idx %i out of bounds\n", opIdx);
33617                 return -1;
33618             }
33619         } // getOperandSize
33620
33621         bool
33622         isSrcOperand(int opIdx) override
33623         {
33624             switch (opIdx) {
33625               case 0: //src_0
33626                 return true;
33627               case 1: //src_1
33628                 return true;
33629               case 2: //sdst
33630                 return false;
33631               default:
33632                 fatal("op idx %i out of bounds\n", opIdx);
33633                 return false;
33634             }
33635         } // isSrcOperand
33636
33637         bool
33638         isDstOperand(int opIdx) override
33639         {
33640             switch (opIdx) {
33641               case 0: //src_0
33642                 return false;
33643               case 1: //src_1
33644                 return false;
33645               case 2: //sdst
33646                 return true;
33647               default:
33648                 fatal("op idx %i out of bounds\n", opIdx);
33649                 return false;
33650             }
33651         } // isDstOperand
33652
33653         void execute(GPUDynInstPtr) override;
33654     }; // Inst_VOP3__V_CMP_NLT_F16
33655
33656     class Inst_VOP3__V_CMP_TRU_F16 : public Inst_VOP3
33657     {
33658       public:
33659         Inst_VOP3__V_CMP_TRU_F16(InFmt_VOP3*);
33660         ~Inst_VOP3__V_CMP_TRU_F16();
33661
33662         int
33663         getNumOperands() override
33664         {
33665             return numDstRegOperands() + numSrcRegOperands();
33666         } // getNumOperands
33667
33668         int numDstRegOperands() override { return 1; }
33669         int numSrcRegOperands() override { return 2; }
33670
33671         int
33672         getOperandSize(int opIdx) override
33673         {
33674             switch (opIdx) {
33675               case 0: //src_0
33676                 return 2;
33677               case 1: //src_1
33678                 return 2;
33679               case 2: //sdst
33680                 return 8;
33681               default:
33682                 fatal("op idx %i out of bounds\n", opIdx);
33683                 return -1;
33684             }
33685         } // getOperandSize
33686
33687         bool
33688         isSrcOperand(int opIdx) override
33689         {
33690             switch (opIdx) {
33691               case 0: //src_0
33692                 return true;
33693               case 1: //src_1
33694                 return true;
33695               case 2: //sdst
33696                 return false;
33697               default:
33698                 fatal("op idx %i out of bounds\n", opIdx);
33699                 return false;
33700             }
33701         } // isSrcOperand
33702
33703         bool
33704         isDstOperand(int opIdx) override
33705         {
33706             switch (opIdx) {
33707               case 0: //src_0
33708                 return false;
33709               case 1: //src_1
33710                 return false;
33711               case 2: //sdst
33712                 return true;
33713               default:
33714                 fatal("op idx %i out of bounds\n", opIdx);
33715                 return false;
33716             }
33717         } // isDstOperand
33718
33719         void execute(GPUDynInstPtr) override;
33720     }; // Inst_VOP3__V_CMP_TRU_F16
33721
33722     class Inst_VOP3__V_CMPX_F_F16 : public Inst_VOP3
33723     {
33724       public:
33725         Inst_VOP3__V_CMPX_F_F16(InFmt_VOP3*);
33726         ~Inst_VOP3__V_CMPX_F_F16();
33727
33728         int
33729         getNumOperands() override
33730         {
33731             return numDstRegOperands() + numSrcRegOperands();
33732         } // getNumOperands
33733
33734         int numDstRegOperands() override { return 1; }
33735         int numSrcRegOperands() override { return 2; }
33736
33737         int
33738         getOperandSize(int opIdx) override
33739         {
33740             switch (opIdx) {
33741               case 0: //src_0
33742                 return 2;
33743               case 1: //src_1
33744                 return 2;
33745               case 2: //sdst
33746                 return 8;
33747               default:
33748                 fatal("op idx %i out of bounds\n", opIdx);
33749                 return -1;
33750             }
33751         } // getOperandSize
33752
33753         bool
33754         isSrcOperand(int opIdx) override
33755         {
33756             switch (opIdx) {
33757               case 0: //src_0
33758                 return true;
33759               case 1: //src_1
33760                 return true;
33761               case 2: //sdst
33762                 return false;
33763               default:
33764                 fatal("op idx %i out of bounds\n", opIdx);
33765                 return false;
33766             }
33767         } // isSrcOperand
33768
33769         bool
33770         isDstOperand(int opIdx) override
33771         {
33772             switch (opIdx) {
33773               case 0: //src_0
33774                 return false;
33775               case 1: //src_1
33776                 return false;
33777               case 2: //sdst
33778                 return true;
33779               default:
33780                 fatal("op idx %i out of bounds\n", opIdx);
33781                 return false;
33782             }
33783         } // isDstOperand
33784
33785         void execute(GPUDynInstPtr) override;
33786     }; // Inst_VOP3__V_CMPX_F_F16
33787
33788     class Inst_VOP3__V_CMPX_LT_F16 : public Inst_VOP3
33789     {
33790       public:
33791         Inst_VOP3__V_CMPX_LT_F16(InFmt_VOP3*);
33792         ~Inst_VOP3__V_CMPX_LT_F16();
33793
33794         int
33795         getNumOperands() override
33796         {
33797             return numDstRegOperands() + numSrcRegOperands();
33798         } // getNumOperands
33799
33800         int numDstRegOperands() override { return 1; }
33801         int numSrcRegOperands() override { return 2; }
33802
33803         int
33804         getOperandSize(int opIdx) override
33805         {
33806             switch (opIdx) {
33807               case 0: //src_0
33808                 return 2;
33809               case 1: //src_1
33810                 return 2;
33811               case 2: //sdst
33812                 return 8;
33813               default:
33814                 fatal("op idx %i out of bounds\n", opIdx);
33815                 return -1;
33816             }
33817         } // getOperandSize
33818
33819         bool
33820         isSrcOperand(int opIdx) override
33821         {
33822             switch (opIdx) {
33823               case 0: //src_0
33824                 return true;
33825               case 1: //src_1
33826                 return true;
33827               case 2: //sdst
33828                 return false;
33829               default:
33830                 fatal("op idx %i out of bounds\n", opIdx);
33831                 return false;
33832             }
33833         } // isSrcOperand
33834
33835         bool
33836         isDstOperand(int opIdx) override
33837         {
33838             switch (opIdx) {
33839               case 0: //src_0
33840                 return false;
33841               case 1: //src_1
33842                 return false;
33843               case 2: //sdst
33844                 return true;
33845               default:
33846                 fatal("op idx %i out of bounds\n", opIdx);
33847                 return false;
33848             }
33849         } // isDstOperand
33850
33851         void execute(GPUDynInstPtr) override;
33852     }; // Inst_VOP3__V_CMPX_LT_F16
33853
33854     class Inst_VOP3__V_CMPX_EQ_F16 : public Inst_VOP3
33855     {
33856       public:
33857         Inst_VOP3__V_CMPX_EQ_F16(InFmt_VOP3*);
33858         ~Inst_VOP3__V_CMPX_EQ_F16();
33859
33860         int
33861         getNumOperands() override
33862         {
33863             return numDstRegOperands() + numSrcRegOperands();
33864         } // getNumOperands
33865
33866         int numDstRegOperands() override { return 1; }
33867         int numSrcRegOperands() override { return 2; }
33868
33869         int
33870         getOperandSize(int opIdx) override
33871         {
33872             switch (opIdx) {
33873               case 0: //src_0
33874                 return 2;
33875               case 1: //src_1
33876                 return 2;
33877               case 2: //sdst
33878                 return 8;
33879               default:
33880                 fatal("op idx %i out of bounds\n", opIdx);
33881                 return -1;
33882             }
33883         } // getOperandSize
33884
33885         bool
33886         isSrcOperand(int opIdx) override
33887         {
33888             switch (opIdx) {
33889               case 0: //src_0
33890                 return true;
33891               case 1: //src_1
33892                 return true;
33893               case 2: //sdst
33894                 return false;
33895               default:
33896                 fatal("op idx %i out of bounds\n", opIdx);
33897                 return false;
33898             }
33899         } // isSrcOperand
33900
33901         bool
33902         isDstOperand(int opIdx) override
33903         {
33904             switch (opIdx) {
33905               case 0: //src_0
33906                 return false;
33907               case 1: //src_1
33908                 return false;
33909               case 2: //sdst
33910                 return true;
33911               default:
33912                 fatal("op idx %i out of bounds\n", opIdx);
33913                 return false;
33914             }
33915         } // isDstOperand
33916
33917         void execute(GPUDynInstPtr) override;
33918     }; // Inst_VOP3__V_CMPX_EQ_F16
33919
33920     class Inst_VOP3__V_CMPX_LE_F16 : public Inst_VOP3
33921     {
33922       public:
33923         Inst_VOP3__V_CMPX_LE_F16(InFmt_VOP3*);
33924         ~Inst_VOP3__V_CMPX_LE_F16();
33925
33926         int
33927         getNumOperands() override
33928         {
33929             return numDstRegOperands() + numSrcRegOperands();
33930         } // getNumOperands
33931
33932         int numDstRegOperands() override { return 1; }
33933         int numSrcRegOperands() override { return 2; }
33934
33935         int
33936         getOperandSize(int opIdx) override
33937         {
33938             switch (opIdx) {
33939               case 0: //src_0
33940                 return 2;
33941               case 1: //src_1
33942                 return 2;
33943               case 2: //sdst
33944                 return 8;
33945               default:
33946                 fatal("op idx %i out of bounds\n", opIdx);
33947                 return -1;
33948             }
33949         } // getOperandSize
33950
33951         bool
33952         isSrcOperand(int opIdx) override
33953         {
33954             switch (opIdx) {
33955               case 0: //src_0
33956                 return true;
33957               case 1: //src_1
33958                 return true;
33959               case 2: //sdst
33960                 return false;
33961               default:
33962                 fatal("op idx %i out of bounds\n", opIdx);
33963                 return false;
33964             }
33965         } // isSrcOperand
33966
33967         bool
33968         isDstOperand(int opIdx) override
33969         {
33970             switch (opIdx) {
33971               case 0: //src_0
33972                 return false;
33973               case 1: //src_1
33974                 return false;
33975               case 2: //sdst
33976                 return true;
33977               default:
33978                 fatal("op idx %i out of bounds\n", opIdx);
33979                 return false;
33980             }
33981         } // isDstOperand
33982
33983         void execute(GPUDynInstPtr) override;
33984     }; // Inst_VOP3__V_CMPX_LE_F16
33985
33986     class Inst_VOP3__V_CMPX_GT_F16 : public Inst_VOP3
33987     {
33988       public:
33989         Inst_VOP3__V_CMPX_GT_F16(InFmt_VOP3*);
33990         ~Inst_VOP3__V_CMPX_GT_F16();
33991
33992         int
33993         getNumOperands() override
33994         {
33995             return numDstRegOperands() + numSrcRegOperands();
33996         } // getNumOperands
33997
33998         int numDstRegOperands() override { return 1; }
33999         int numSrcRegOperands() override { return 2; }
34000
34001         int
34002         getOperandSize(int opIdx) override
34003         {
34004             switch (opIdx) {
34005               case 0: //src_0
34006                 return 2;
34007               case 1: //src_1
34008                 return 2;
34009               case 2: //sdst
34010                 return 8;
34011               default:
34012                 fatal("op idx %i out of bounds\n", opIdx);
34013                 return -1;
34014             }
34015         } // getOperandSize
34016
34017         bool
34018         isSrcOperand(int opIdx) override
34019         {
34020             switch (opIdx) {
34021               case 0: //src_0
34022                 return true;
34023               case 1: //src_1
34024                 return true;
34025               case 2: //sdst
34026                 return false;
34027               default:
34028                 fatal("op idx %i out of bounds\n", opIdx);
34029                 return false;
34030             }
34031         } // isSrcOperand
34032
34033         bool
34034         isDstOperand(int opIdx) override
34035         {
34036             switch (opIdx) {
34037               case 0: //src_0
34038                 return false;
34039               case 1: //src_1
34040                 return false;
34041               case 2: //sdst
34042                 return true;
34043               default:
34044                 fatal("op idx %i out of bounds\n", opIdx);
34045                 return false;
34046             }
34047         } // isDstOperand
34048
34049         void execute(GPUDynInstPtr) override;
34050     }; // Inst_VOP3__V_CMPX_GT_F16
34051
34052     class Inst_VOP3__V_CMPX_LG_F16 : public Inst_VOP3
34053     {
34054       public:
34055         Inst_VOP3__V_CMPX_LG_F16(InFmt_VOP3*);
34056         ~Inst_VOP3__V_CMPX_LG_F16();
34057
34058         int
34059         getNumOperands() override
34060         {
34061             return numDstRegOperands() + numSrcRegOperands();
34062         } // getNumOperands
34063
34064         int numDstRegOperands() override { return 1; }
34065         int numSrcRegOperands() override { return 2; }
34066
34067         int
34068         getOperandSize(int opIdx) override
34069         {
34070             switch (opIdx) {
34071               case 0: //src_0
34072                 return 2;
34073               case 1: //src_1
34074                 return 2;
34075               case 2: //sdst
34076                 return 8;
34077               default:
34078                 fatal("op idx %i out of bounds\n", opIdx);
34079                 return -1;
34080             }
34081         } // getOperandSize
34082
34083         bool
34084         isSrcOperand(int opIdx) override
34085         {
34086             switch (opIdx) {
34087               case 0: //src_0
34088                 return true;
34089               case 1: //src_1
34090                 return true;
34091               case 2: //sdst
34092                 return false;
34093               default:
34094                 fatal("op idx %i out of bounds\n", opIdx);
34095                 return false;
34096             }
34097         } // isSrcOperand
34098
34099         bool
34100         isDstOperand(int opIdx) override
34101         {
34102             switch (opIdx) {
34103               case 0: //src_0
34104                 return false;
34105               case 1: //src_1
34106                 return false;
34107               case 2: //sdst
34108                 return true;
34109               default:
34110                 fatal("op idx %i out of bounds\n", opIdx);
34111                 return false;
34112             }
34113         } // isDstOperand
34114
34115         void execute(GPUDynInstPtr) override;
34116     }; // Inst_VOP3__V_CMPX_LG_F16
34117
34118     class Inst_VOP3__V_CMPX_GE_F16 : public Inst_VOP3
34119     {
34120       public:
34121         Inst_VOP3__V_CMPX_GE_F16(InFmt_VOP3*);
34122         ~Inst_VOP3__V_CMPX_GE_F16();
34123
34124         int
34125         getNumOperands() override
34126         {
34127             return numDstRegOperands() + numSrcRegOperands();
34128         } // getNumOperands
34129
34130         int numDstRegOperands() override { return 1; }
34131         int numSrcRegOperands() override { return 2; }
34132
34133         int
34134         getOperandSize(int opIdx) override
34135         {
34136             switch (opIdx) {
34137               case 0: //src_0
34138                 return 2;
34139               case 1: //src_1
34140                 return 2;
34141               case 2: //sdst
34142                 return 8;
34143               default:
34144                 fatal("op idx %i out of bounds\n", opIdx);
34145                 return -1;
34146             }
34147         } // getOperandSize
34148
34149         bool
34150         isSrcOperand(int opIdx) override
34151         {
34152             switch (opIdx) {
34153               case 0: //src_0
34154                 return true;
34155               case 1: //src_1
34156                 return true;
34157               case 2: //sdst
34158                 return false;
34159               default:
34160                 fatal("op idx %i out of bounds\n", opIdx);
34161                 return false;
34162             }
34163         } // isSrcOperand
34164
34165         bool
34166         isDstOperand(int opIdx) override
34167         {
34168             switch (opIdx) {
34169               case 0: //src_0
34170                 return false;
34171               case 1: //src_1
34172                 return false;
34173               case 2: //sdst
34174                 return true;
34175               default:
34176                 fatal("op idx %i out of bounds\n", opIdx);
34177                 return false;
34178             }
34179         } // isDstOperand
34180
34181         void execute(GPUDynInstPtr) override;
34182     }; // Inst_VOP3__V_CMPX_GE_F16
34183
34184     class Inst_VOP3__V_CMPX_O_F16 : public Inst_VOP3
34185     {
34186       public:
34187         Inst_VOP3__V_CMPX_O_F16(InFmt_VOP3*);
34188         ~Inst_VOP3__V_CMPX_O_F16();
34189
34190         int
34191         getNumOperands() override
34192         {
34193             return numDstRegOperands() + numSrcRegOperands();
34194         } // getNumOperands
34195
34196         int numDstRegOperands() override { return 1; }
34197         int numSrcRegOperands() override { return 2; }
34198
34199         int
34200         getOperandSize(int opIdx) override
34201         {
34202             switch (opIdx) {
34203               case 0: //src_0
34204                 return 2;
34205               case 1: //src_1
34206                 return 2;
34207               case 2: //sdst
34208                 return 8;
34209               default:
34210                 fatal("op idx %i out of bounds\n", opIdx);
34211                 return -1;
34212             }
34213         } // getOperandSize
34214
34215         bool
34216         isSrcOperand(int opIdx) override
34217         {
34218             switch (opIdx) {
34219               case 0: //src_0
34220                 return true;
34221               case 1: //src_1
34222                 return true;
34223               case 2: //sdst
34224                 return false;
34225               default:
34226                 fatal("op idx %i out of bounds\n", opIdx);
34227                 return false;
34228             }
34229         } // isSrcOperand
34230
34231         bool
34232         isDstOperand(int opIdx) override
34233         {
34234             switch (opIdx) {
34235               case 0: //src_0
34236                 return false;
34237               case 1: //src_1
34238                 return false;
34239               case 2: //sdst
34240                 return true;
34241               default:
34242                 fatal("op idx %i out of bounds\n", opIdx);
34243                 return false;
34244             }
34245         } // isDstOperand
34246
34247         void execute(GPUDynInstPtr) override;
34248     }; // Inst_VOP3__V_CMPX_O_F16
34249
34250     class Inst_VOP3__V_CMPX_U_F16 : public Inst_VOP3
34251     {
34252       public:
34253         Inst_VOP3__V_CMPX_U_F16(InFmt_VOP3*);
34254         ~Inst_VOP3__V_CMPX_U_F16();
34255
34256         int
34257         getNumOperands() override
34258         {
34259             return numDstRegOperands() + numSrcRegOperands();
34260         } // getNumOperands
34261
34262         int numDstRegOperands() override { return 1; }
34263         int numSrcRegOperands() override { return 2; }
34264
34265         int
34266         getOperandSize(int opIdx) override
34267         {
34268             switch (opIdx) {
34269               case 0: //src_0
34270                 return 2;
34271               case 1: //src_1
34272                 return 2;
34273               case 2: //sdst
34274                 return 8;
34275               default:
34276                 fatal("op idx %i out of bounds\n", opIdx);
34277                 return -1;
34278             }
34279         } // getOperandSize
34280
34281         bool
34282         isSrcOperand(int opIdx) override
34283         {
34284             switch (opIdx) {
34285               case 0: //src_0
34286                 return true;
34287               case 1: //src_1
34288                 return true;
34289               case 2: //sdst
34290                 return false;
34291               default:
34292                 fatal("op idx %i out of bounds\n", opIdx);
34293                 return false;
34294             }
34295         } // isSrcOperand
34296
34297         bool
34298         isDstOperand(int opIdx) override
34299         {
34300             switch (opIdx) {
34301               case 0: //src_0
34302                 return false;
34303               case 1: //src_1
34304                 return false;
34305               case 2: //sdst
34306                 return true;
34307               default:
34308                 fatal("op idx %i out of bounds\n", opIdx);
34309                 return false;
34310             }
34311         } // isDstOperand
34312
34313         void execute(GPUDynInstPtr) override;
34314     }; // Inst_VOP3__V_CMPX_U_F16
34315
34316     class Inst_VOP3__V_CMPX_NGE_F16 : public Inst_VOP3
34317     {
34318       public:
34319         Inst_VOP3__V_CMPX_NGE_F16(InFmt_VOP3*);
34320         ~Inst_VOP3__V_CMPX_NGE_F16();
34321
34322         int
34323         getNumOperands() override
34324         {
34325             return numDstRegOperands() + numSrcRegOperands();
34326         } // getNumOperands
34327
34328         int numDstRegOperands() override { return 1; }
34329         int numSrcRegOperands() override { return 2; }
34330
34331         int
34332         getOperandSize(int opIdx) override
34333         {
34334             switch (opIdx) {
34335               case 0: //src_0
34336                 return 2;
34337               case 1: //src_1
34338                 return 2;
34339               case 2: //sdst
34340                 return 8;
34341               default:
34342                 fatal("op idx %i out of bounds\n", opIdx);
34343                 return -1;
34344             }
34345         } // getOperandSize
34346
34347         bool
34348         isSrcOperand(int opIdx) override
34349         {
34350             switch (opIdx) {
34351               case 0: //src_0
34352                 return true;
34353               case 1: //src_1
34354                 return true;
34355               case 2: //sdst
34356                 return false;
34357               default:
34358                 fatal("op idx %i out of bounds\n", opIdx);
34359                 return false;
34360             }
34361         } // isSrcOperand
34362
34363         bool
34364         isDstOperand(int opIdx) override
34365         {
34366             switch (opIdx) {
34367               case 0: //src_0
34368                 return false;
34369               case 1: //src_1
34370                 return false;
34371               case 2: //sdst
34372                 return true;
34373               default:
34374                 fatal("op idx %i out of bounds\n", opIdx);
34375                 return false;
34376             }
34377         } // isDstOperand
34378
34379         void execute(GPUDynInstPtr) override;
34380     }; // Inst_VOP3__V_CMPX_NGE_F16
34381
34382     class Inst_VOP3__V_CMPX_NLG_F16 : public Inst_VOP3
34383     {
34384       public:
34385         Inst_VOP3__V_CMPX_NLG_F16(InFmt_VOP3*);
34386         ~Inst_VOP3__V_CMPX_NLG_F16();
34387
34388         int
34389         getNumOperands() override
34390         {
34391             return numDstRegOperands() + numSrcRegOperands();
34392         } // getNumOperands
34393
34394         int numDstRegOperands() override { return 1; }
34395         int numSrcRegOperands() override { return 2; }
34396
34397         int
34398         getOperandSize(int opIdx) override
34399         {
34400             switch (opIdx) {
34401               case 0: //src_0
34402                 return 2;
34403               case 1: //src_1
34404                 return 2;
34405               case 2: //sdst
34406                 return 8;
34407               default:
34408                 fatal("op idx %i out of bounds\n", opIdx);
34409                 return -1;
34410             }
34411         } // getOperandSize
34412
34413         bool
34414         isSrcOperand(int opIdx) override
34415         {
34416             switch (opIdx) {
34417               case 0: //src_0
34418                 return true;
34419               case 1: //src_1
34420                 return true;
34421               case 2: //sdst
34422                 return false;
34423               default:
34424                 fatal("op idx %i out of bounds\n", opIdx);
34425                 return false;
34426             }
34427         } // isSrcOperand
34428
34429         bool
34430         isDstOperand(int opIdx) override
34431         {
34432             switch (opIdx) {
34433               case 0: //src_0
34434                 return false;
34435               case 1: //src_1
34436                 return false;
34437               case 2: //sdst
34438                 return true;
34439               default:
34440                 fatal("op idx %i out of bounds\n", opIdx);
34441                 return false;
34442             }
34443         } // isDstOperand
34444
34445         void execute(GPUDynInstPtr) override;
34446     }; // Inst_VOP3__V_CMPX_NLG_F16
34447
34448     class Inst_VOP3__V_CMPX_NGT_F16 : public Inst_VOP3
34449     {
34450       public:
34451         Inst_VOP3__V_CMPX_NGT_F16(InFmt_VOP3*);
34452         ~Inst_VOP3__V_CMPX_NGT_F16();
34453
34454         int
34455         getNumOperands() override
34456         {
34457             return numDstRegOperands() + numSrcRegOperands();
34458         } // getNumOperands
34459
34460         int numDstRegOperands() override { return 1; }
34461         int numSrcRegOperands() override { return 2; }
34462
34463         int
34464         getOperandSize(int opIdx) override
34465         {
34466             switch (opIdx) {
34467               case 0: //src_0
34468                 return 2;
34469               case 1: //src_1
34470                 return 2;
34471               case 2: //sdst
34472                 return 8;
34473               default:
34474                 fatal("op idx %i out of bounds\n", opIdx);
34475                 return -1;
34476             }
34477         } // getOperandSize
34478
34479         bool
34480         isSrcOperand(int opIdx) override
34481         {
34482             switch (opIdx) {
34483               case 0: //src_0
34484                 return true;
34485               case 1: //src_1
34486                 return true;
34487               case 2: //sdst
34488                 return false;
34489               default:
34490                 fatal("op idx %i out of bounds\n", opIdx);
34491                 return false;
34492             }
34493         } // isSrcOperand
34494
34495         bool
34496         isDstOperand(int opIdx) override
34497         {
34498             switch (opIdx) {
34499               case 0: //src_0
34500                 return false;
34501               case 1: //src_1
34502                 return false;
34503               case 2: //sdst
34504                 return true;
34505               default:
34506                 fatal("op idx %i out of bounds\n", opIdx);
34507                 return false;
34508             }
34509         } // isDstOperand
34510
34511         void execute(GPUDynInstPtr) override;
34512     }; // Inst_VOP3__V_CMPX_NGT_F16
34513
34514     class Inst_VOP3__V_CMPX_NLE_F16 : public Inst_VOP3
34515     {
34516       public:
34517         Inst_VOP3__V_CMPX_NLE_F16(InFmt_VOP3*);
34518         ~Inst_VOP3__V_CMPX_NLE_F16();
34519
34520         int
34521         getNumOperands() override
34522         {
34523             return numDstRegOperands() + numSrcRegOperands();
34524         } // getNumOperands
34525
34526         int numDstRegOperands() override { return 1; }
34527         int numSrcRegOperands() override { return 2; }
34528
34529         int
34530         getOperandSize(int opIdx) override
34531         {
34532             switch (opIdx) {
34533               case 0: //src_0
34534                 return 2;
34535               case 1: //src_1
34536                 return 2;
34537               case 2: //sdst
34538                 return 8;
34539               default:
34540                 fatal("op idx %i out of bounds\n", opIdx);
34541                 return -1;
34542             }
34543         } // getOperandSize
34544
34545         bool
34546         isSrcOperand(int opIdx) override
34547         {
34548             switch (opIdx) {
34549               case 0: //src_0
34550                 return true;
34551               case 1: //src_1
34552                 return true;
34553               case 2: //sdst
34554                 return false;
34555               default:
34556                 fatal("op idx %i out of bounds\n", opIdx);
34557                 return false;
34558             }
34559         } // isSrcOperand
34560
34561         bool
34562         isDstOperand(int opIdx) override
34563         {
34564             switch (opIdx) {
34565               case 0: //src_0
34566                 return false;
34567               case 1: //src_1
34568                 return false;
34569               case 2: //sdst
34570                 return true;
34571               default:
34572                 fatal("op idx %i out of bounds\n", opIdx);
34573                 return false;
34574             }
34575         } // isDstOperand
34576
34577         void execute(GPUDynInstPtr) override;
34578     }; // Inst_VOP3__V_CMPX_NLE_F16
34579
34580     class Inst_VOP3__V_CMPX_NEQ_F16 : public Inst_VOP3
34581     {
34582       public:
34583         Inst_VOP3__V_CMPX_NEQ_F16(InFmt_VOP3*);
34584         ~Inst_VOP3__V_CMPX_NEQ_F16();
34585
34586         int
34587         getNumOperands() override
34588         {
34589             return numDstRegOperands() + numSrcRegOperands();
34590         } // getNumOperands
34591
34592         int numDstRegOperands() override { return 1; }
34593         int numSrcRegOperands() override { return 2; }
34594
34595         int
34596         getOperandSize(int opIdx) override
34597         {
34598             switch (opIdx) {
34599               case 0: //src_0
34600                 return 2;
34601               case 1: //src_1
34602                 return 2;
34603               case 2: //sdst
34604                 return 8;
34605               default:
34606                 fatal("op idx %i out of bounds\n", opIdx);
34607                 return -1;
34608             }
34609         } // getOperandSize
34610
34611         bool
34612         isSrcOperand(int opIdx) override
34613         {
34614             switch (opIdx) {
34615               case 0: //src_0
34616                 return true;
34617               case 1: //src_1
34618                 return true;
34619               case 2: //sdst
34620                 return false;
34621               default:
34622                 fatal("op idx %i out of bounds\n", opIdx);
34623                 return false;
34624             }
34625         } // isSrcOperand
34626
34627         bool
34628         isDstOperand(int opIdx) override
34629         {
34630             switch (opIdx) {
34631               case 0: //src_0
34632                 return false;
34633               case 1: //src_1
34634                 return false;
34635               case 2: //sdst
34636                 return true;
34637               default:
34638                 fatal("op idx %i out of bounds\n", opIdx);
34639                 return false;
34640             }
34641         } // isDstOperand
34642
34643         void execute(GPUDynInstPtr) override;
34644     }; // Inst_VOP3__V_CMPX_NEQ_F16
34645
34646     class Inst_VOP3__V_CMPX_NLT_F16 : public Inst_VOP3
34647     {
34648       public:
34649         Inst_VOP3__V_CMPX_NLT_F16(InFmt_VOP3*);
34650         ~Inst_VOP3__V_CMPX_NLT_F16();
34651
34652         int
34653         getNumOperands() override
34654         {
34655             return numDstRegOperands() + numSrcRegOperands();
34656         } // getNumOperands
34657
34658         int numDstRegOperands() override { return 1; }
34659         int numSrcRegOperands() override { return 2; }
34660
34661         int
34662         getOperandSize(int opIdx) override
34663         {
34664             switch (opIdx) {
34665               case 0: //src_0
34666                 return 2;
34667               case 1: //src_1
34668                 return 2;
34669               case 2: //sdst
34670                 return 8;
34671               default:
34672                 fatal("op idx %i out of bounds\n", opIdx);
34673                 return -1;
34674             }
34675         } // getOperandSize
34676
34677         bool
34678         isSrcOperand(int opIdx) override
34679         {
34680             switch (opIdx) {
34681               case 0: //src_0
34682                 return true;
34683               case 1: //src_1
34684                 return true;
34685               case 2: //sdst
34686                 return false;
34687               default:
34688                 fatal("op idx %i out of bounds\n", opIdx);
34689                 return false;
34690             }
34691         } // isSrcOperand
34692
34693         bool
34694         isDstOperand(int opIdx) override
34695         {
34696             switch (opIdx) {
34697               case 0: //src_0
34698                 return false;
34699               case 1: //src_1
34700                 return false;
34701               case 2: //sdst
34702                 return true;
34703               default:
34704                 fatal("op idx %i out of bounds\n", opIdx);
34705                 return false;
34706             }
34707         } // isDstOperand
34708
34709         void execute(GPUDynInstPtr) override;
34710     }; // Inst_VOP3__V_CMPX_NLT_F16
34711
34712     class Inst_VOP3__V_CMPX_TRU_F16 : public Inst_VOP3
34713     {
34714       public:
34715         Inst_VOP3__V_CMPX_TRU_F16(InFmt_VOP3*);
34716         ~Inst_VOP3__V_CMPX_TRU_F16();
34717
34718         int
34719         getNumOperands() override
34720         {
34721             return numDstRegOperands() + numSrcRegOperands();
34722         } // getNumOperands
34723
34724         int numDstRegOperands() override { return 1; }
34725         int numSrcRegOperands() override { return 2; }
34726
34727         int
34728         getOperandSize(int opIdx) override
34729         {
34730             switch (opIdx) {
34731               case 0: //src_0
34732                 return 2;
34733               case 1: //src_1
34734                 return 2;
34735               case 2: //sdst
34736                 return 8;
34737               default:
34738                 fatal("op idx %i out of bounds\n", opIdx);
34739                 return -1;
34740             }
34741         } // getOperandSize
34742
34743         bool
34744         isSrcOperand(int opIdx) override
34745         {
34746             switch (opIdx) {
34747               case 0: //src_0
34748                 return true;
34749               case 1: //src_1
34750                 return true;
34751               case 2: //sdst
34752                 return false;
34753               default:
34754                 fatal("op idx %i out of bounds\n", opIdx);
34755                 return false;
34756             }
34757         } // isSrcOperand
34758
34759         bool
34760         isDstOperand(int opIdx) override
34761         {
34762             switch (opIdx) {
34763               case 0: //src_0
34764                 return false;
34765               case 1: //src_1
34766                 return false;
34767               case 2: //sdst
34768                 return true;
34769               default:
34770                 fatal("op idx %i out of bounds\n", opIdx);
34771                 return false;
34772             }
34773         } // isDstOperand
34774
34775         void execute(GPUDynInstPtr) override;
34776     }; // Inst_VOP3__V_CMPX_TRU_F16
34777
34778     class Inst_VOP3__V_CMP_F_F32 : public Inst_VOP3
34779     {
34780       public:
34781         Inst_VOP3__V_CMP_F_F32(InFmt_VOP3*);
34782         ~Inst_VOP3__V_CMP_F_F32();
34783
34784         int
34785         getNumOperands() override
34786         {
34787             return numDstRegOperands() + numSrcRegOperands();
34788         } // getNumOperands
34789
34790         int numDstRegOperands() override { return 1; }
34791         int numSrcRegOperands() override { return 2; }
34792
34793         int
34794         getOperandSize(int opIdx) override
34795         {
34796             switch (opIdx) {
34797               case 0: //src_0
34798                 return 4;
34799               case 1: //src_1
34800                 return 4;
34801               case 2: //sdst
34802                 return 8;
34803               default:
34804                 fatal("op idx %i out of bounds\n", opIdx);
34805                 return -1;
34806             }
34807         } // getOperandSize
34808
34809         bool
34810         isSrcOperand(int opIdx) override
34811         {
34812             switch (opIdx) {
34813               case 0: //src_0
34814                 return true;
34815               case 1: //src_1
34816                 return true;
34817               case 2: //sdst
34818                 return false;
34819               default:
34820                 fatal("op idx %i out of bounds\n", opIdx);
34821                 return false;
34822             }
34823         } // isSrcOperand
34824
34825         bool
34826         isDstOperand(int opIdx) override
34827         {
34828             switch (opIdx) {
34829               case 0: //src_0
34830                 return false;
34831               case 1: //src_1
34832                 return false;
34833               case 2: //sdst
34834                 return true;
34835               default:
34836                 fatal("op idx %i out of bounds\n", opIdx);
34837                 return false;
34838             }
34839         } // isDstOperand
34840
34841         void execute(GPUDynInstPtr) override;
34842     }; // Inst_VOP3__V_CMP_F_F32
34843
34844     class Inst_VOP3__V_CMP_LT_F32 : public Inst_VOP3
34845     {
34846       public:
34847         Inst_VOP3__V_CMP_LT_F32(InFmt_VOP3*);
34848         ~Inst_VOP3__V_CMP_LT_F32();
34849
34850         int
34851         getNumOperands() override
34852         {
34853             return numDstRegOperands() + numSrcRegOperands();
34854         } // getNumOperands
34855
34856         int numDstRegOperands() override { return 1; }
34857         int numSrcRegOperands() override { return 2; }
34858
34859         int
34860         getOperandSize(int opIdx) override
34861         {
34862             switch (opIdx) {
34863               case 0: //src_0
34864                 return 4;
34865               case 1: //src_1
34866                 return 4;
34867               case 2: //sdst
34868                 return 8;
34869               default:
34870                 fatal("op idx %i out of bounds\n", opIdx);
34871                 return -1;
34872             }
34873         } // getOperandSize
34874
34875         bool
34876         isSrcOperand(int opIdx) override
34877         {
34878             switch (opIdx) {
34879               case 0: //src_0
34880                 return true;
34881               case 1: //src_1
34882                 return true;
34883               case 2: //sdst
34884                 return false;
34885               default:
34886                 fatal("op idx %i out of bounds\n", opIdx);
34887                 return false;
34888             }
34889         } // isSrcOperand
34890
34891         bool
34892         isDstOperand(int opIdx) override
34893         {
34894             switch (opIdx) {
34895               case 0: //src_0
34896                 return false;
34897               case 1: //src_1
34898                 return false;
34899               case 2: //sdst
34900                 return true;
34901               default:
34902                 fatal("op idx %i out of bounds\n", opIdx);
34903                 return false;
34904             }
34905         } // isDstOperand
34906
34907         void execute(GPUDynInstPtr) override;
34908     }; // Inst_VOP3__V_CMP_LT_F32
34909
34910     class Inst_VOP3__V_CMP_EQ_F32 : public Inst_VOP3
34911     {
34912       public:
34913         Inst_VOP3__V_CMP_EQ_F32(InFmt_VOP3*);
34914         ~Inst_VOP3__V_CMP_EQ_F32();
34915
34916         int
34917         getNumOperands() override
34918         {
34919             return numDstRegOperands() + numSrcRegOperands();
34920         } // getNumOperands
34921
34922         int numDstRegOperands() override { return 1; }
34923         int numSrcRegOperands() override { return 2; }
34924
34925         int
34926         getOperandSize(int opIdx) override
34927         {
34928             switch (opIdx) {
34929               case 0: //src_0
34930                 return 4;
34931               case 1: //src_1
34932                 return 4;
34933               case 2: //sdst
34934                 return 8;
34935               default:
34936                 fatal("op idx %i out of bounds\n", opIdx);
34937                 return -1;
34938             }
34939         } // getOperandSize
34940
34941         bool
34942         isSrcOperand(int opIdx) override
34943         {
34944             switch (opIdx) {
34945               case 0: //src_0
34946                 return true;
34947               case 1: //src_1
34948                 return true;
34949               case 2: //sdst
34950                 return false;
34951               default:
34952                 fatal("op idx %i out of bounds\n", opIdx);
34953                 return false;
34954             }
34955         } // isSrcOperand
34956
34957         bool
34958         isDstOperand(int opIdx) override
34959         {
34960             switch (opIdx) {
34961               case 0: //src_0
34962                 return false;
34963               case 1: //src_1
34964                 return false;
34965               case 2: //sdst
34966                 return true;
34967               default:
34968                 fatal("op idx %i out of bounds\n", opIdx);
34969                 return false;
34970             }
34971         } // isDstOperand
34972
34973         void execute(GPUDynInstPtr) override;
34974     }; // Inst_VOP3__V_CMP_EQ_F32
34975
34976     class Inst_VOP3__V_CMP_LE_F32 : public Inst_VOP3
34977     {
34978       public:
34979         Inst_VOP3__V_CMP_LE_F32(InFmt_VOP3*);
34980         ~Inst_VOP3__V_CMP_LE_F32();
34981
34982         int
34983         getNumOperands() override
34984         {
34985             return numDstRegOperands() + numSrcRegOperands();
34986         } // getNumOperands
34987
34988         int numDstRegOperands() override { return 1; }
34989         int numSrcRegOperands() override { return 2; }
34990
34991         int
34992         getOperandSize(int opIdx) override
34993         {
34994             switch (opIdx) {
34995               case 0: //src_0
34996                 return 4;
34997               case 1: //src_1
34998                 return 4;
34999               case 2: //sdst
35000                 return 8;
35001               default:
35002                 fatal("op idx %i out of bounds\n", opIdx);
35003                 return -1;
35004             }
35005         } // getOperandSize
35006
35007         bool
35008         isSrcOperand(int opIdx) override
35009         {
35010             switch (opIdx) {
35011               case 0: //src_0
35012                 return true;
35013               case 1: //src_1
35014                 return true;
35015               case 2: //sdst
35016                 return false;
35017               default:
35018                 fatal("op idx %i out of bounds\n", opIdx);
35019                 return false;
35020             }
35021         } // isSrcOperand
35022
35023         bool
35024         isDstOperand(int opIdx) override
35025         {
35026             switch (opIdx) {
35027               case 0: //src_0
35028                 return false;
35029               case 1: //src_1
35030                 return false;
35031               case 2: //sdst
35032                 return true;
35033               default:
35034                 fatal("op idx %i out of bounds\n", opIdx);
35035                 return false;
35036             }
35037         } // isDstOperand
35038
35039         void execute(GPUDynInstPtr) override;
35040     }; // Inst_VOP3__V_CMP_LE_F32
35041
35042     class Inst_VOP3__V_CMP_GT_F32 : public Inst_VOP3
35043     {
35044       public:
35045         Inst_VOP3__V_CMP_GT_F32(InFmt_VOP3*);
35046         ~Inst_VOP3__V_CMP_GT_F32();
35047
35048         int
35049         getNumOperands() override
35050         {
35051             return numDstRegOperands() + numSrcRegOperands();
35052         } // getNumOperands
35053
35054         int numDstRegOperands() override { return 1; }
35055         int numSrcRegOperands() override { return 2; }
35056
35057         int
35058         getOperandSize(int opIdx) override
35059         {
35060             switch (opIdx) {
35061               case 0: //src_0
35062                 return 4;
35063               case 1: //src_1
35064                 return 4;
35065               case 2: //sdst
35066                 return 8;
35067               default:
35068                 fatal("op idx %i out of bounds\n", opIdx);
35069                 return -1;
35070             }
35071         } // getOperandSize
35072
35073         bool
35074         isSrcOperand(int opIdx) override
35075         {
35076             switch (opIdx) {
35077               case 0: //src_0
35078                 return true;
35079               case 1: //src_1
35080                 return true;
35081               case 2: //sdst
35082                 return false;
35083               default:
35084                 fatal("op idx %i out of bounds\n", opIdx);
35085                 return false;
35086             }
35087         } // isSrcOperand
35088
35089         bool
35090         isDstOperand(int opIdx) override
35091         {
35092             switch (opIdx) {
35093               case 0: //src_0
35094                 return false;
35095               case 1: //src_1
35096                 return false;
35097               case 2: //sdst
35098                 return true;
35099               default:
35100                 fatal("op idx %i out of bounds\n", opIdx);
35101                 return false;
35102             }
35103         } // isDstOperand
35104
35105         void execute(GPUDynInstPtr) override;
35106     }; // Inst_VOP3__V_CMP_GT_F32
35107
35108     class Inst_VOP3__V_CMP_LG_F32 : public Inst_VOP3
35109     {
35110       public:
35111         Inst_VOP3__V_CMP_LG_F32(InFmt_VOP3*);
35112         ~Inst_VOP3__V_CMP_LG_F32();
35113
35114         int
35115         getNumOperands() override
35116         {
35117             return numDstRegOperands() + numSrcRegOperands();
35118         } // getNumOperands
35119
35120         int numDstRegOperands() override { return 1; }
35121         int numSrcRegOperands() override { return 2; }
35122
35123         int
35124         getOperandSize(int opIdx) override
35125         {
35126             switch (opIdx) {
35127               case 0: //src_0
35128                 return 4;
35129               case 1: //src_1
35130                 return 4;
35131               case 2: //sdst
35132                 return 8;
35133               default:
35134                 fatal("op idx %i out of bounds\n", opIdx);
35135                 return -1;
35136             }
35137         } // getOperandSize
35138
35139         bool
35140         isSrcOperand(int opIdx) override
35141         {
35142             switch (opIdx) {
35143               case 0: //src_0
35144                 return true;
35145               case 1: //src_1
35146                 return true;
35147               case 2: //sdst
35148                 return false;
35149               default:
35150                 fatal("op idx %i out of bounds\n", opIdx);
35151                 return false;
35152             }
35153         } // isSrcOperand
35154
35155         bool
35156         isDstOperand(int opIdx) override
35157         {
35158             switch (opIdx) {
35159               case 0: //src_0
35160                 return false;
35161               case 1: //src_1
35162                 return false;
35163               case 2: //sdst
35164                 return true;
35165               default:
35166                 fatal("op idx %i out of bounds\n", opIdx);
35167                 return false;
35168             }
35169         } // isDstOperand
35170
35171         void execute(GPUDynInstPtr) override;
35172     }; // Inst_VOP3__V_CMP_LG_F32
35173
35174     class Inst_VOP3__V_CMP_GE_F32 : public Inst_VOP3
35175     {
35176       public:
35177         Inst_VOP3__V_CMP_GE_F32(InFmt_VOP3*);
35178         ~Inst_VOP3__V_CMP_GE_F32();
35179
35180         int
35181         getNumOperands() override
35182         {
35183             return numDstRegOperands() + numSrcRegOperands();
35184         } // getNumOperands
35185
35186         int numDstRegOperands() override { return 1; }
35187         int numSrcRegOperands() override { return 2; }
35188
35189         int
35190         getOperandSize(int opIdx) override
35191         {
35192             switch (opIdx) {
35193               case 0: //src_0
35194                 return 4;
35195               case 1: //src_1
35196                 return 4;
35197               case 2: //sdst
35198                 return 8;
35199               default:
35200                 fatal("op idx %i out of bounds\n", opIdx);
35201                 return -1;
35202             }
35203         } // getOperandSize
35204
35205         bool
35206         isSrcOperand(int opIdx) override
35207         {
35208             switch (opIdx) {
35209               case 0: //src_0
35210                 return true;
35211               case 1: //src_1
35212                 return true;
35213               case 2: //sdst
35214                 return false;
35215               default:
35216                 fatal("op idx %i out of bounds\n", opIdx);
35217                 return false;
35218             }
35219         } // isSrcOperand
35220
35221         bool
35222         isDstOperand(int opIdx) override
35223         {
35224             switch (opIdx) {
35225               case 0: //src_0
35226                 return false;
35227               case 1: //src_1
35228                 return false;
35229               case 2: //sdst
35230                 return true;
35231               default:
35232                 fatal("op idx %i out of bounds\n", opIdx);
35233                 return false;
35234             }
35235         } // isDstOperand
35236
35237         void execute(GPUDynInstPtr) override;
35238     }; // Inst_VOP3__V_CMP_GE_F32
35239
35240     class Inst_VOP3__V_CMP_O_F32 : public Inst_VOP3
35241     {
35242       public:
35243         Inst_VOP3__V_CMP_O_F32(InFmt_VOP3*);
35244         ~Inst_VOP3__V_CMP_O_F32();
35245
35246         int
35247         getNumOperands() override
35248         {
35249             return numDstRegOperands() + numSrcRegOperands();
35250         } // getNumOperands
35251
35252         int numDstRegOperands() override { return 1; }
35253         int numSrcRegOperands() override { return 2; }
35254
35255         int
35256         getOperandSize(int opIdx) override
35257         {
35258             switch (opIdx) {
35259               case 0: //src_0
35260                 return 4;
35261               case 1: //src_1
35262                 return 4;
35263               case 2: //sdst
35264                 return 8;
35265               default:
35266                 fatal("op idx %i out of bounds\n", opIdx);
35267                 return -1;
35268             }
35269         } // getOperandSize
35270
35271         bool
35272         isSrcOperand(int opIdx) override
35273         {
35274             switch (opIdx) {
35275               case 0: //src_0
35276                 return true;
35277               case 1: //src_1
35278                 return true;
35279               case 2: //sdst
35280                 return false;
35281               default:
35282                 fatal("op idx %i out of bounds\n", opIdx);
35283                 return false;
35284             }
35285         } // isSrcOperand
35286
35287         bool
35288         isDstOperand(int opIdx) override
35289         {
35290             switch (opIdx) {
35291               case 0: //src_0
35292                 return false;
35293               case 1: //src_1
35294                 return false;
35295               case 2: //sdst
35296                 return true;
35297               default:
35298                 fatal("op idx %i out of bounds\n", opIdx);
35299                 return false;
35300             }
35301         } // isDstOperand
35302
35303         void execute(GPUDynInstPtr) override;
35304     }; // Inst_VOP3__V_CMP_O_F32
35305
35306     class Inst_VOP3__V_CMP_U_F32 : public Inst_VOP3
35307     {
35308       public:
35309         Inst_VOP3__V_CMP_U_F32(InFmt_VOP3*);
35310         ~Inst_VOP3__V_CMP_U_F32();
35311
35312         int
35313         getNumOperands() override
35314         {
35315             return numDstRegOperands() + numSrcRegOperands();
35316         } // getNumOperands
35317
35318         int numDstRegOperands() override { return 1; }
35319         int numSrcRegOperands() override { return 2; }
35320
35321         int
35322         getOperandSize(int opIdx) override
35323         {
35324             switch (opIdx) {
35325               case 0: //src_0
35326                 return 4;
35327               case 1: //src_1
35328                 return 4;
35329               case 2: //sdst
35330                 return 8;
35331               default:
35332                 fatal("op idx %i out of bounds\n", opIdx);
35333                 return -1;
35334             }
35335         } // getOperandSize
35336
35337         bool
35338         isSrcOperand(int opIdx) override
35339         {
35340             switch (opIdx) {
35341               case 0: //src_0
35342                 return true;
35343               case 1: //src_1
35344                 return true;
35345               case 2: //sdst
35346                 return false;
35347               default:
35348                 fatal("op idx %i out of bounds\n", opIdx);
35349                 return false;
35350             }
35351         } // isSrcOperand
35352
35353         bool
35354         isDstOperand(int opIdx) override
35355         {
35356             switch (opIdx) {
35357               case 0: //src_0
35358                 return false;
35359               case 1: //src_1
35360                 return false;
35361               case 2: //sdst
35362                 return true;
35363               default:
35364                 fatal("op idx %i out of bounds\n", opIdx);
35365                 return false;
35366             }
35367         } // isDstOperand
35368
35369         void execute(GPUDynInstPtr) override;
35370     }; // Inst_VOP3__V_CMP_U_F32
35371
35372     class Inst_VOP3__V_CMP_NGE_F32 : public Inst_VOP3
35373     {
35374       public:
35375         Inst_VOP3__V_CMP_NGE_F32(InFmt_VOP3*);
35376         ~Inst_VOP3__V_CMP_NGE_F32();
35377
35378         int
35379         getNumOperands() override
35380         {
35381             return numDstRegOperands() + numSrcRegOperands();
35382         } // getNumOperands
35383
35384         int numDstRegOperands() override { return 1; }
35385         int numSrcRegOperands() override { return 2; }
35386
35387         int
35388         getOperandSize(int opIdx) override
35389         {
35390             switch (opIdx) {
35391               case 0: //src_0
35392                 return 4;
35393               case 1: //src_1
35394                 return 4;
35395               case 2: //sdst
35396                 return 8;
35397               default:
35398                 fatal("op idx %i out of bounds\n", opIdx);
35399                 return -1;
35400             }
35401         } // getOperandSize
35402
35403         bool
35404         isSrcOperand(int opIdx) override
35405         {
35406             switch (opIdx) {
35407               case 0: //src_0
35408                 return true;
35409               case 1: //src_1
35410                 return true;
35411               case 2: //sdst
35412                 return false;
35413               default:
35414                 fatal("op idx %i out of bounds\n", opIdx);
35415                 return false;
35416             }
35417         } // isSrcOperand
35418
35419         bool
35420         isDstOperand(int opIdx) override
35421         {
35422             switch (opIdx) {
35423               case 0: //src_0
35424                 return false;
35425               case 1: //src_1
35426                 return false;
35427               case 2: //sdst
35428                 return true;
35429               default:
35430                 fatal("op idx %i out of bounds\n", opIdx);
35431                 return false;
35432             }
35433         } // isDstOperand
35434
35435         void execute(GPUDynInstPtr) override;
35436     }; // Inst_VOP3__V_CMP_NGE_F32
35437
35438     class Inst_VOP3__V_CMP_NLG_F32 : public Inst_VOP3
35439     {
35440       public:
35441         Inst_VOP3__V_CMP_NLG_F32(InFmt_VOP3*);
35442         ~Inst_VOP3__V_CMP_NLG_F32();
35443
35444         int
35445         getNumOperands() override
35446         {
35447             return numDstRegOperands() + numSrcRegOperands();
35448         } // getNumOperands
35449
35450         int numDstRegOperands() override { return 1; }
35451         int numSrcRegOperands() override { return 2; }
35452
35453         int
35454         getOperandSize(int opIdx) override
35455         {
35456             switch (opIdx) {
35457               case 0: //src_0
35458                 return 4;
35459               case 1: //src_1
35460                 return 4;
35461               case 2: //sdst
35462                 return 8;
35463               default:
35464                 fatal("op idx %i out of bounds\n", opIdx);
35465                 return -1;
35466             }
35467         } // getOperandSize
35468
35469         bool
35470         isSrcOperand(int opIdx) override
35471         {
35472             switch (opIdx) {
35473               case 0: //src_0
35474                 return true;
35475               case 1: //src_1
35476                 return true;
35477               case 2: //sdst
35478                 return false;
35479               default:
35480                 fatal("op idx %i out of bounds\n", opIdx);
35481                 return false;
35482             }
35483         } // isSrcOperand
35484
35485         bool
35486         isDstOperand(int opIdx) override
35487         {
35488             switch (opIdx) {
35489               case 0: //src_0
35490                 return false;
35491               case 1: //src_1
35492                 return false;
35493               case 2: //sdst
35494                 return true;
35495               default:
35496                 fatal("op idx %i out of bounds\n", opIdx);
35497                 return false;
35498             }
35499         } // isDstOperand
35500
35501         void execute(GPUDynInstPtr) override;
35502     }; // Inst_VOP3__V_CMP_NLG_F32
35503
35504     class Inst_VOP3__V_CMP_NGT_F32 : public Inst_VOP3
35505     {
35506       public:
35507         Inst_VOP3__V_CMP_NGT_F32(InFmt_VOP3*);
35508         ~Inst_VOP3__V_CMP_NGT_F32();
35509
35510         int
35511         getNumOperands() override
35512         {
35513             return numDstRegOperands() + numSrcRegOperands();
35514         } // getNumOperands
35515
35516         int numDstRegOperands() override { return 1; }
35517         int numSrcRegOperands() override { return 2; }
35518
35519         int
35520         getOperandSize(int opIdx) override
35521         {
35522             switch (opIdx) {
35523               case 0: //src_0
35524                 return 4;
35525               case 1: //src_1
35526                 return 4;
35527               case 2: //sdst
35528                 return 8;
35529               default:
35530                 fatal("op idx %i out of bounds\n", opIdx);
35531                 return -1;
35532             }
35533         } // getOperandSize
35534
35535         bool
35536         isSrcOperand(int opIdx) override
35537         {
35538             switch (opIdx) {
35539               case 0: //src_0
35540                 return true;
35541               case 1: //src_1
35542                 return true;
35543               case 2: //sdst
35544                 return false;
35545               default:
35546                 fatal("op idx %i out of bounds\n", opIdx);
35547                 return false;
35548             }
35549         } // isSrcOperand
35550
35551         bool
35552         isDstOperand(int opIdx) override
35553         {
35554             switch (opIdx) {
35555               case 0: //src_0
35556                 return false;
35557               case 1: //src_1
35558                 return false;
35559               case 2: //sdst
35560                 return true;
35561               default:
35562                 fatal("op idx %i out of bounds\n", opIdx);
35563                 return false;
35564             }
35565         } // isDstOperand
35566
35567         void execute(GPUDynInstPtr) override;
35568     }; // Inst_VOP3__V_CMP_NGT_F32
35569
35570     class Inst_VOP3__V_CMP_NLE_F32 : public Inst_VOP3
35571     {
35572       public:
35573         Inst_VOP3__V_CMP_NLE_F32(InFmt_VOP3*);
35574         ~Inst_VOP3__V_CMP_NLE_F32();
35575
35576         int
35577         getNumOperands() override
35578         {
35579             return numDstRegOperands() + numSrcRegOperands();
35580         } // getNumOperands
35581
35582         int numDstRegOperands() override { return 1; }
35583         int numSrcRegOperands() override { return 2; }
35584
35585         int
35586         getOperandSize(int opIdx) override
35587         {
35588             switch (opIdx) {
35589               case 0: //src_0
35590                 return 4;
35591               case 1: //src_1
35592                 return 4;
35593               case 2: //sdst
35594                 return 8;
35595               default:
35596                 fatal("op idx %i out of bounds\n", opIdx);
35597                 return -1;
35598             }
35599         } // getOperandSize
35600
35601         bool
35602         isSrcOperand(int opIdx) override
35603         {
35604             switch (opIdx) {
35605               case 0: //src_0
35606                 return true;
35607               case 1: //src_1
35608                 return true;
35609               case 2: //sdst
35610                 return false;
35611               default:
35612                 fatal("op idx %i out of bounds\n", opIdx);
35613                 return false;
35614             }
35615         } // isSrcOperand
35616
35617         bool
35618         isDstOperand(int opIdx) override
35619         {
35620             switch (opIdx) {
35621               case 0: //src_0
35622                 return false;
35623               case 1: //src_1
35624                 return false;
35625               case 2: //sdst
35626                 return true;
35627               default:
35628                 fatal("op idx %i out of bounds\n", opIdx);
35629                 return false;
35630             }
35631         } // isDstOperand
35632
35633         void execute(GPUDynInstPtr) override;
35634     }; // Inst_VOP3__V_CMP_NLE_F32
35635
35636     class Inst_VOP3__V_CMP_NEQ_F32 : public Inst_VOP3
35637     {
35638       public:
35639         Inst_VOP3__V_CMP_NEQ_F32(InFmt_VOP3*);
35640         ~Inst_VOP3__V_CMP_NEQ_F32();
35641
35642         int
35643         getNumOperands() override
35644         {
35645             return numDstRegOperands() + numSrcRegOperands();
35646         } // getNumOperands
35647
35648         int numDstRegOperands() override { return 1; }
35649         int numSrcRegOperands() override { return 2; }
35650
35651         int
35652         getOperandSize(int opIdx) override
35653         {
35654             switch (opIdx) {
35655               case 0: //src_0
35656                 return 4;
35657               case 1: //src_1
35658                 return 4;
35659               case 2: //sdst
35660                 return 8;
35661               default:
35662                 fatal("op idx %i out of bounds\n", opIdx);
35663                 return -1;
35664             }
35665         } // getOperandSize
35666
35667         bool
35668         isSrcOperand(int opIdx) override
35669         {
35670             switch (opIdx) {
35671               case 0: //src_0
35672                 return true;
35673               case 1: //src_1
35674                 return true;
35675               case 2: //sdst
35676                 return false;
35677               default:
35678                 fatal("op idx %i out of bounds\n", opIdx);
35679                 return false;
35680             }
35681         } // isSrcOperand
35682
35683         bool
35684         isDstOperand(int opIdx) override
35685         {
35686             switch (opIdx) {
35687               case 0: //src_0
35688                 return false;
35689               case 1: //src_1
35690                 return false;
35691               case 2: //sdst
35692                 return true;
35693               default:
35694                 fatal("op idx %i out of bounds\n", opIdx);
35695                 return false;
35696             }
35697         } // isDstOperand
35698
35699         void execute(GPUDynInstPtr) override;
35700     }; // Inst_VOP3__V_CMP_NEQ_F32
35701
35702     class Inst_VOP3__V_CMP_NLT_F32 : public Inst_VOP3
35703     {
35704       public:
35705         Inst_VOP3__V_CMP_NLT_F32(InFmt_VOP3*);
35706         ~Inst_VOP3__V_CMP_NLT_F32();
35707
35708         int
35709         getNumOperands() override
35710         {
35711             return numDstRegOperands() + numSrcRegOperands();
35712         } // getNumOperands
35713
35714         int numDstRegOperands() override { return 1; }
35715         int numSrcRegOperands() override { return 2; }
35716
35717         int
35718         getOperandSize(int opIdx) override
35719         {
35720             switch (opIdx) {
35721               case 0: //src_0
35722                 return 4;
35723               case 1: //src_1
35724                 return 4;
35725               case 2: //sdst
35726                 return 8;
35727               default:
35728                 fatal("op idx %i out of bounds\n", opIdx);
35729                 return -1;
35730             }
35731         } // getOperandSize
35732
35733         bool
35734         isSrcOperand(int opIdx) override
35735         {
35736             switch (opIdx) {
35737               case 0: //src_0
35738                 return true;
35739               case 1: //src_1
35740                 return true;
35741               case 2: //sdst
35742                 return false;
35743               default:
35744                 fatal("op idx %i out of bounds\n", opIdx);
35745                 return false;
35746             }
35747         } // isSrcOperand
35748
35749         bool
35750         isDstOperand(int opIdx) override
35751         {
35752             switch (opIdx) {
35753               case 0: //src_0
35754                 return false;
35755               case 1: //src_1
35756                 return false;
35757               case 2: //sdst
35758                 return true;
35759               default:
35760                 fatal("op idx %i out of bounds\n", opIdx);
35761                 return false;
35762             }
35763         } // isDstOperand
35764
35765         void execute(GPUDynInstPtr) override;
35766     }; // Inst_VOP3__V_CMP_NLT_F32
35767
35768     class Inst_VOP3__V_CMP_TRU_F32 : public Inst_VOP3
35769     {
35770       public:
35771         Inst_VOP3__V_CMP_TRU_F32(InFmt_VOP3*);
35772         ~Inst_VOP3__V_CMP_TRU_F32();
35773
35774         int
35775         getNumOperands() override
35776         {
35777             return numDstRegOperands() + numSrcRegOperands();
35778         } // getNumOperands
35779
35780         int numDstRegOperands() override { return 1; }
35781         int numSrcRegOperands() override { return 2; }
35782
35783         int
35784         getOperandSize(int opIdx) override
35785         {
35786             switch (opIdx) {
35787               case 0: //src_0
35788                 return 4;
35789               case 1: //src_1
35790                 return 4;
35791               case 2: //sdst
35792                 return 8;
35793               default:
35794                 fatal("op idx %i out of bounds\n", opIdx);
35795                 return -1;
35796             }
35797         } // getOperandSize
35798
35799         bool
35800         isSrcOperand(int opIdx) override
35801         {
35802             switch (opIdx) {
35803               case 0: //src_0
35804                 return true;
35805               case 1: //src_1
35806                 return true;
35807               case 2: //sdst
35808                 return false;
35809               default:
35810                 fatal("op idx %i out of bounds\n", opIdx);
35811                 return false;
35812             }
35813         } // isSrcOperand
35814
35815         bool
35816         isDstOperand(int opIdx) override
35817         {
35818             switch (opIdx) {
35819               case 0: //src_0
35820                 return false;
35821               case 1: //src_1
35822                 return false;
35823               case 2: //sdst
35824                 return true;
35825               default:
35826                 fatal("op idx %i out of bounds\n", opIdx);
35827                 return false;
35828             }
35829         } // isDstOperand
35830
35831         void execute(GPUDynInstPtr) override;
35832     }; // Inst_VOP3__V_CMP_TRU_F32
35833
35834     class Inst_VOP3__V_CMPX_F_F32 : public Inst_VOP3
35835     {
35836       public:
35837         Inst_VOP3__V_CMPX_F_F32(InFmt_VOP3*);
35838         ~Inst_VOP3__V_CMPX_F_F32();
35839
35840         int
35841         getNumOperands() override
35842         {
35843             return numDstRegOperands() + numSrcRegOperands();
35844         } // getNumOperands
35845
35846         int numDstRegOperands() override { return 1; }
35847         int numSrcRegOperands() override { return 2; }
35848
35849         int
35850         getOperandSize(int opIdx) override
35851         {
35852             switch (opIdx) {
35853               case 0: //src_0
35854                 return 4;
35855               case 1: //src_1
35856                 return 4;
35857               case 2: //sdst
35858                 return 8;
35859               default:
35860                 fatal("op idx %i out of bounds\n", opIdx);
35861                 return -1;
35862             }
35863         } // getOperandSize
35864
35865         bool
35866         isSrcOperand(int opIdx) override
35867         {
35868             switch (opIdx) {
35869               case 0: //src_0
35870                 return true;
35871               case 1: //src_1
35872                 return true;
35873               case 2: //sdst
35874                 return false;
35875               default:
35876                 fatal("op idx %i out of bounds\n", opIdx);
35877                 return false;
35878             }
35879         } // isSrcOperand
35880
35881         bool
35882         isDstOperand(int opIdx) override
35883         {
35884             switch (opIdx) {
35885               case 0: //src_0
35886                 return false;
35887               case 1: //src_1
35888                 return false;
35889               case 2: //sdst
35890                 return true;
35891               default:
35892                 fatal("op idx %i out of bounds\n", opIdx);
35893                 return false;
35894             }
35895         } // isDstOperand
35896
35897         void execute(GPUDynInstPtr) override;
35898     }; // Inst_VOP3__V_CMPX_F_F32
35899
35900     class Inst_VOP3__V_CMPX_LT_F32 : public Inst_VOP3
35901     {
35902       public:
35903         Inst_VOP3__V_CMPX_LT_F32(InFmt_VOP3*);
35904         ~Inst_VOP3__V_CMPX_LT_F32();
35905
35906         int
35907         getNumOperands() override
35908         {
35909             return numDstRegOperands() + numSrcRegOperands();
35910         } // getNumOperands
35911
35912         int numDstRegOperands() override { return 1; }
35913         int numSrcRegOperands() override { return 2; }
35914
35915         int
35916         getOperandSize(int opIdx) override
35917         {
35918             switch (opIdx) {
35919               case 0: //src_0
35920                 return 4;
35921               case 1: //src_1
35922                 return 4;
35923               case 2: //sdst
35924                 return 8;
35925               default:
35926                 fatal("op idx %i out of bounds\n", opIdx);
35927                 return -1;
35928             }
35929         } // getOperandSize
35930
35931         bool
35932         isSrcOperand(int opIdx) override
35933         {
35934             switch (opIdx) {
35935               case 0: //src_0
35936                 return true;
35937               case 1: //src_1
35938                 return true;
35939               case 2: //sdst
35940                 return false;
35941               default:
35942                 fatal("op idx %i out of bounds\n", opIdx);
35943                 return false;
35944             }
35945         } // isSrcOperand
35946
35947         bool
35948         isDstOperand(int opIdx) override
35949         {
35950             switch (opIdx) {
35951               case 0: //src_0
35952                 return false;
35953               case 1: //src_1
35954                 return false;
35955               case 2: //sdst
35956                 return true;
35957               default:
35958                 fatal("op idx %i out of bounds\n", opIdx);
35959                 return false;
35960             }
35961         } // isDstOperand
35962
35963         void execute(GPUDynInstPtr) override;
35964     }; // Inst_VOP3__V_CMPX_LT_F32
35965
35966     class Inst_VOP3__V_CMPX_EQ_F32 : public Inst_VOP3
35967     {
35968       public:
35969         Inst_VOP3__V_CMPX_EQ_F32(InFmt_VOP3*);
35970         ~Inst_VOP3__V_CMPX_EQ_F32();
35971
35972         int
35973         getNumOperands() override
35974         {
35975             return numDstRegOperands() + numSrcRegOperands();
35976         } // getNumOperands
35977
35978         int numDstRegOperands() override { return 1; }
35979         int numSrcRegOperands() override { return 2; }
35980
35981         int
35982         getOperandSize(int opIdx) override
35983         {
35984             switch (opIdx) {
35985               case 0: //src_0
35986                 return 4;
35987               case 1: //src_1
35988                 return 4;
35989               case 2: //sdst
35990                 return 8;
35991               default:
35992                 fatal("op idx %i out of bounds\n", opIdx);
35993                 return -1;
35994             }
35995         } // getOperandSize
35996
35997         bool
35998         isSrcOperand(int opIdx) override
35999         {
36000             switch (opIdx) {
36001               case 0: //src_0
36002                 return true;
36003               case 1: //src_1
36004                 return true;
36005               case 2: //sdst
36006                 return false;
36007               default:
36008                 fatal("op idx %i out of bounds\n", opIdx);
36009                 return false;
36010             }
36011         } // isSrcOperand
36012
36013         bool
36014         isDstOperand(int opIdx) override
36015         {
36016             switch (opIdx) {
36017               case 0: //src_0
36018                 return false;
36019               case 1: //src_1
36020                 return false;
36021               case 2: //sdst
36022                 return true;
36023               default:
36024                 fatal("op idx %i out of bounds\n", opIdx);
36025                 return false;
36026             }
36027         } // isDstOperand
36028
36029         void execute(GPUDynInstPtr) override;
36030     }; // Inst_VOP3__V_CMPX_EQ_F32
36031
36032     class Inst_VOP3__V_CMPX_LE_F32 : public Inst_VOP3
36033     {
36034       public:
36035         Inst_VOP3__V_CMPX_LE_F32(InFmt_VOP3*);
36036         ~Inst_VOP3__V_CMPX_LE_F32();
36037
36038         int
36039         getNumOperands() override
36040         {
36041             return numDstRegOperands() + numSrcRegOperands();
36042         } // getNumOperands
36043
36044         int numDstRegOperands() override { return 1; }
36045         int numSrcRegOperands() override { return 2; }
36046
36047         int
36048         getOperandSize(int opIdx) override
36049         {
36050             switch (opIdx) {
36051               case 0: //src_0
36052                 return 4;
36053               case 1: //src_1
36054                 return 4;
36055               case 2: //sdst
36056                 return 8;
36057               default:
36058                 fatal("op idx %i out of bounds\n", opIdx);
36059                 return -1;
36060             }
36061         } // getOperandSize
36062
36063         bool
36064         isSrcOperand(int opIdx) override
36065         {
36066             switch (opIdx) {
36067               case 0: //src_0
36068                 return true;
36069               case 1: //src_1
36070                 return true;
36071               case 2: //sdst
36072                 return false;
36073               default:
36074                 fatal("op idx %i out of bounds\n", opIdx);
36075                 return false;
36076             }
36077         } // isSrcOperand
36078
36079         bool
36080         isDstOperand(int opIdx) override
36081         {
36082             switch (opIdx) {
36083               case 0: //src_0
36084                 return false;
36085               case 1: //src_1
36086                 return false;
36087               case 2: //sdst
36088                 return true;
36089               default:
36090                 fatal("op idx %i out of bounds\n", opIdx);
36091                 return false;
36092             }
36093         } // isDstOperand
36094
36095         void execute(GPUDynInstPtr) override;
36096     }; // Inst_VOP3__V_CMPX_LE_F32
36097
36098     class Inst_VOP3__V_CMPX_GT_F32 : public Inst_VOP3
36099     {
36100       public:
36101         Inst_VOP3__V_CMPX_GT_F32(InFmt_VOP3*);
36102         ~Inst_VOP3__V_CMPX_GT_F32();
36103
36104         int
36105         getNumOperands() override
36106         {
36107             return numDstRegOperands() + numSrcRegOperands();
36108         } // getNumOperands
36109
36110         int numDstRegOperands() override { return 1; }
36111         int numSrcRegOperands() override { return 2; }
36112
36113         int
36114         getOperandSize(int opIdx) override
36115         {
36116             switch (opIdx) {
36117               case 0: //src_0
36118                 return 4;
36119               case 1: //src_1
36120                 return 4;
36121               case 2: //sdst
36122                 return 8;
36123               default:
36124                 fatal("op idx %i out of bounds\n", opIdx);
36125                 return -1;
36126             }
36127         } // getOperandSize
36128
36129         bool
36130         isSrcOperand(int opIdx) override
36131         {
36132             switch (opIdx) {
36133               case 0: //src_0
36134                 return true;
36135               case 1: //src_1
36136                 return true;
36137               case 2: //sdst
36138                 return false;
36139               default:
36140                 fatal("op idx %i out of bounds\n", opIdx);
36141                 return false;
36142             }
36143         } // isSrcOperand
36144
36145         bool
36146         isDstOperand(int opIdx) override
36147         {
36148             switch (opIdx) {
36149               case 0: //src_0
36150                 return false;
36151               case 1: //src_1
36152                 return false;
36153               case 2: //sdst
36154                 return true;
36155               default:
36156                 fatal("op idx %i out of bounds\n", opIdx);
36157                 return false;
36158             }
36159         } // isDstOperand
36160
36161         void execute(GPUDynInstPtr) override;
36162     }; // Inst_VOP3__V_CMPX_GT_F32
36163
36164     class Inst_VOP3__V_CMPX_LG_F32 : public Inst_VOP3
36165     {
36166       public:
36167         Inst_VOP3__V_CMPX_LG_F32(InFmt_VOP3*);
36168         ~Inst_VOP3__V_CMPX_LG_F32();
36169
36170         int
36171         getNumOperands() override
36172         {
36173             return numDstRegOperands() + numSrcRegOperands();
36174         } // getNumOperands
36175
36176         int numDstRegOperands() override { return 1; }
36177         int numSrcRegOperands() override { return 2; }
36178
36179         int
36180         getOperandSize(int opIdx) override
36181         {
36182             switch (opIdx) {
36183               case 0: //src_0
36184                 return 4;
36185               case 1: //src_1
36186                 return 4;
36187               case 2: //sdst
36188                 return 8;
36189               default:
36190                 fatal("op idx %i out of bounds\n", opIdx);
36191                 return -1;
36192             }
36193         } // getOperandSize
36194
36195         bool
36196         isSrcOperand(int opIdx) override
36197         {
36198             switch (opIdx) {
36199               case 0: //src_0
36200                 return true;
36201               case 1: //src_1
36202                 return true;
36203               case 2: //sdst
36204                 return false;
36205               default:
36206                 fatal("op idx %i out of bounds\n", opIdx);
36207                 return false;
36208             }
36209         } // isSrcOperand
36210
36211         bool
36212         isDstOperand(int opIdx) override
36213         {
36214             switch (opIdx) {
36215               case 0: //src_0
36216                 return false;
36217               case 1: //src_1
36218                 return false;
36219               case 2: //sdst
36220                 return true;
36221               default:
36222                 fatal("op idx %i out of bounds\n", opIdx);
36223                 return false;
36224             }
36225         } // isDstOperand
36226
36227         void execute(GPUDynInstPtr) override;
36228     }; // Inst_VOP3__V_CMPX_LG_F32
36229
36230     class Inst_VOP3__V_CMPX_GE_F32 : public Inst_VOP3
36231     {
36232       public:
36233         Inst_VOP3__V_CMPX_GE_F32(InFmt_VOP3*);
36234         ~Inst_VOP3__V_CMPX_GE_F32();
36235
36236         int
36237         getNumOperands() override
36238         {
36239             return numDstRegOperands() + numSrcRegOperands();
36240         } // getNumOperands
36241
36242         int numDstRegOperands() override { return 1; }
36243         int numSrcRegOperands() override { return 2; }
36244
36245         int
36246         getOperandSize(int opIdx) override
36247         {
36248             switch (opIdx) {
36249               case 0: //src_0
36250                 return 4;
36251               case 1: //src_1
36252                 return 4;
36253               case 2: //sdst
36254                 return 8;
36255               default:
36256                 fatal("op idx %i out of bounds\n", opIdx);
36257                 return -1;
36258             }
36259         } // getOperandSize
36260
36261         bool
36262         isSrcOperand(int opIdx) override
36263         {
36264             switch (opIdx) {
36265               case 0: //src_0
36266                 return true;
36267               case 1: //src_1
36268                 return true;
36269               case 2: //sdst
36270                 return false;
36271               default:
36272                 fatal("op idx %i out of bounds\n", opIdx);
36273                 return false;
36274             }
36275         } // isSrcOperand
36276
36277         bool
36278         isDstOperand(int opIdx) override
36279         {
36280             switch (opIdx) {
36281               case 0: //src_0
36282                 return false;
36283               case 1: //src_1
36284                 return false;
36285               case 2: //sdst
36286                 return true;
36287               default:
36288                 fatal("op idx %i out of bounds\n", opIdx);
36289                 return false;
36290             }
36291         } // isDstOperand
36292
36293         void execute(GPUDynInstPtr) override;
36294     }; // Inst_VOP3__V_CMPX_GE_F32
36295
36296     class Inst_VOP3__V_CMPX_O_F32 : public Inst_VOP3
36297     {
36298       public:
36299         Inst_VOP3__V_CMPX_O_F32(InFmt_VOP3*);
36300         ~Inst_VOP3__V_CMPX_O_F32();
36301
36302         int
36303         getNumOperands() override
36304         {
36305             return numDstRegOperands() + numSrcRegOperands();
36306         } // getNumOperands
36307
36308         int numDstRegOperands() override { return 1; }
36309         int numSrcRegOperands() override { return 2; }
36310
36311         int
36312         getOperandSize(int opIdx) override
36313         {
36314             switch (opIdx) {
36315               case 0: //src_0
36316                 return 4;
36317               case 1: //src_1
36318                 return 4;
36319               case 2: //sdst
36320                 return 8;
36321               default:
36322                 fatal("op idx %i out of bounds\n", opIdx);
36323                 return -1;
36324             }
36325         } // getOperandSize
36326
36327         bool
36328         isSrcOperand(int opIdx) override
36329         {
36330             switch (opIdx) {
36331               case 0: //src_0
36332                 return true;
36333               case 1: //src_1
36334                 return true;
36335               case 2: //sdst
36336                 return false;
36337               default:
36338                 fatal("op idx %i out of bounds\n", opIdx);
36339                 return false;
36340             }
36341         } // isSrcOperand
36342
36343         bool
36344         isDstOperand(int opIdx) override
36345         {
36346             switch (opIdx) {
36347               case 0: //src_0
36348                 return false;
36349               case 1: //src_1
36350                 return false;
36351               case 2: //sdst
36352                 return true;
36353               default:
36354                 fatal("op idx %i out of bounds\n", opIdx);
36355                 return false;
36356             }
36357         } // isDstOperand
36358
36359         void execute(GPUDynInstPtr) override;
36360     }; // Inst_VOP3__V_CMPX_O_F32
36361
36362     class Inst_VOP3__V_CMPX_U_F32 : public Inst_VOP3
36363     {
36364       public:
36365         Inst_VOP3__V_CMPX_U_F32(InFmt_VOP3*);
36366         ~Inst_VOP3__V_CMPX_U_F32();
36367
36368         int
36369         getNumOperands() override
36370         {
36371             return numDstRegOperands() + numSrcRegOperands();
36372         } // getNumOperands
36373
36374         int numDstRegOperands() override { return 1; }
36375         int numSrcRegOperands() override { return 2; }
36376
36377         int
36378         getOperandSize(int opIdx) override
36379         {
36380             switch (opIdx) {
36381               case 0: //src_0
36382                 return 4;
36383               case 1: //src_1
36384                 return 4;
36385               case 2: //sdst
36386                 return 8;
36387               default:
36388                 fatal("op idx %i out of bounds\n", opIdx);
36389                 return -1;
36390             }
36391         } // getOperandSize
36392
36393         bool
36394         isSrcOperand(int opIdx) override
36395         {
36396             switch (opIdx) {
36397               case 0: //src_0
36398                 return true;
36399               case 1: //src_1
36400                 return true;
36401               case 2: //sdst
36402                 return false;
36403               default:
36404                 fatal("op idx %i out of bounds\n", opIdx);
36405                 return false;
36406             }
36407         } // isSrcOperand
36408
36409         bool
36410         isDstOperand(int opIdx) override
36411         {
36412             switch (opIdx) {
36413               case 0: //src_0
36414                 return false;
36415               case 1: //src_1
36416                 return false;
36417               case 2: //sdst
36418                 return true;
36419               default:
36420                 fatal("op idx %i out of bounds\n", opIdx);
36421                 return false;
36422             }
36423         } // isDstOperand
36424
36425         void execute(GPUDynInstPtr) override;
36426     }; // Inst_VOP3__V_CMPX_U_F32
36427
36428     class Inst_VOP3__V_CMPX_NGE_F32 : public Inst_VOP3
36429     {
36430       public:
36431         Inst_VOP3__V_CMPX_NGE_F32(InFmt_VOP3*);
36432         ~Inst_VOP3__V_CMPX_NGE_F32();
36433
36434         int
36435         getNumOperands() override
36436         {
36437             return numDstRegOperands() + numSrcRegOperands();
36438         } // getNumOperands
36439
36440         int numDstRegOperands() override { return 1; }
36441         int numSrcRegOperands() override { return 2; }
36442
36443         int
36444         getOperandSize(int opIdx) override
36445         {
36446             switch (opIdx) {
36447               case 0: //src_0
36448                 return 4;
36449               case 1: //src_1
36450                 return 4;
36451               case 2: //sdst
36452                 return 8;
36453               default:
36454                 fatal("op idx %i out of bounds\n", opIdx);
36455                 return -1;
36456             }
36457         } // getOperandSize
36458
36459         bool
36460         isSrcOperand(int opIdx) override
36461         {
36462             switch (opIdx) {
36463               case 0: //src_0
36464                 return true;
36465               case 1: //src_1
36466                 return true;
36467               case 2: //sdst
36468                 return false;
36469               default:
36470                 fatal("op idx %i out of bounds\n", opIdx);
36471                 return false;
36472             }
36473         } // isSrcOperand
36474
36475         bool
36476         isDstOperand(int opIdx) override
36477         {
36478             switch (opIdx) {
36479               case 0: //src_0
36480                 return false;
36481               case 1: //src_1
36482                 return false;
36483               case 2: //sdst
36484                 return true;
36485               default:
36486                 fatal("op idx %i out of bounds\n", opIdx);
36487                 return false;
36488             }
36489         } // isDstOperand
36490
36491         void execute(GPUDynInstPtr) override;
36492     }; // Inst_VOP3__V_CMPX_NGE_F32
36493
36494     class Inst_VOP3__V_CMPX_NLG_F32 : public Inst_VOP3
36495     {
36496       public:
36497         Inst_VOP3__V_CMPX_NLG_F32(InFmt_VOP3*);
36498         ~Inst_VOP3__V_CMPX_NLG_F32();
36499
36500         int
36501         getNumOperands() override
36502         {
36503             return numDstRegOperands() + numSrcRegOperands();
36504         } // getNumOperands
36505
36506         int numDstRegOperands() override { return 1; }
36507         int numSrcRegOperands() override { return 2; }
36508
36509         int
36510         getOperandSize(int opIdx) override
36511         {
36512             switch (opIdx) {
36513               case 0: //src_0
36514                 return 4;
36515               case 1: //src_1
36516                 return 4;
36517               case 2: //sdst
36518                 return 8;
36519               default:
36520                 fatal("op idx %i out of bounds\n", opIdx);
36521                 return -1;
36522             }
36523         } // getOperandSize
36524
36525         bool
36526         isSrcOperand(int opIdx) override
36527         {
36528             switch (opIdx) {
36529               case 0: //src_0
36530                 return true;
36531               case 1: //src_1
36532                 return true;
36533               case 2: //sdst
36534                 return false;
36535               default:
36536                 fatal("op idx %i out of bounds\n", opIdx);
36537                 return false;
36538             }
36539         } // isSrcOperand
36540
36541         bool
36542         isDstOperand(int opIdx) override
36543         {
36544             switch (opIdx) {
36545               case 0: //src_0
36546                 return false;
36547               case 1: //src_1
36548                 return false;
36549               case 2: //sdst
36550                 return true;
36551               default:
36552                 fatal("op idx %i out of bounds\n", opIdx);
36553                 return false;
36554             }
36555         } // isDstOperand
36556
36557         void execute(GPUDynInstPtr) override;
36558     }; // Inst_VOP3__V_CMPX_NLG_F32
36559
36560     class Inst_VOP3__V_CMPX_NGT_F32 : public Inst_VOP3
36561     {
36562       public:
36563         Inst_VOP3__V_CMPX_NGT_F32(InFmt_VOP3*);
36564         ~Inst_VOP3__V_CMPX_NGT_F32();
36565
36566         int
36567         getNumOperands() override
36568         {
36569             return numDstRegOperands() + numSrcRegOperands();
36570         } // getNumOperands
36571
36572         int numDstRegOperands() override { return 1; }
36573         int numSrcRegOperands() override { return 2; }
36574
36575         int
36576         getOperandSize(int opIdx) override
36577         {
36578             switch (opIdx) {
36579               case 0: //src_0
36580                 return 4;
36581               case 1: //src_1
36582                 return 4;
36583               case 2: //sdst
36584                 return 8;
36585               default:
36586                 fatal("op idx %i out of bounds\n", opIdx);
36587                 return -1;
36588             }
36589         } // getOperandSize
36590
36591         bool
36592         isSrcOperand(int opIdx) override
36593         {
36594             switch (opIdx) {
36595               case 0: //src_0
36596                 return true;
36597               case 1: //src_1
36598                 return true;
36599               case 2: //sdst
36600                 return false;
36601               default:
36602                 fatal("op idx %i out of bounds\n", opIdx);
36603                 return false;
36604             }
36605         } // isSrcOperand
36606
36607         bool
36608         isDstOperand(int opIdx) override
36609         {
36610             switch (opIdx) {
36611               case 0: //src_0
36612                 return false;
36613               case 1: //src_1
36614                 return false;
36615               case 2: //sdst
36616                 return true;
36617               default:
36618                 fatal("op idx %i out of bounds\n", opIdx);
36619                 return false;
36620             }
36621         } // isDstOperand
36622
36623         void execute(GPUDynInstPtr) override;
36624     }; // Inst_VOP3__V_CMPX_NGT_F32
36625
36626     class Inst_VOP3__V_CMPX_NLE_F32 : public Inst_VOP3
36627     {
36628       public:
36629         Inst_VOP3__V_CMPX_NLE_F32(InFmt_VOP3*);
36630         ~Inst_VOP3__V_CMPX_NLE_F32();
36631
36632         int
36633         getNumOperands() override
36634         {
36635             return numDstRegOperands() + numSrcRegOperands();
36636         } // getNumOperands
36637
36638         int numDstRegOperands() override { return 1; }
36639         int numSrcRegOperands() override { return 2; }
36640
36641         int
36642         getOperandSize(int opIdx) override
36643         {
36644             switch (opIdx) {
36645               case 0: //src_0
36646                 return 4;
36647               case 1: //src_1
36648                 return 4;
36649               case 2: //sdst
36650                 return 8;
36651               default:
36652                 fatal("op idx %i out of bounds\n", opIdx);
36653                 return -1;
36654             }
36655         } // getOperandSize
36656
36657         bool
36658         isSrcOperand(int opIdx) override
36659         {
36660             switch (opIdx) {
36661               case 0: //src_0
36662                 return true;
36663               case 1: //src_1
36664                 return true;
36665               case 2: //sdst
36666                 return false;
36667               default:
36668                 fatal("op idx %i out of bounds\n", opIdx);
36669                 return false;
36670             }
36671         } // isSrcOperand
36672
36673         bool
36674         isDstOperand(int opIdx) override
36675         {
36676             switch (opIdx) {
36677               case 0: //src_0
36678                 return false;
36679               case 1: //src_1
36680                 return false;
36681               case 2: //sdst
36682                 return true;
36683               default:
36684                 fatal("op idx %i out of bounds\n", opIdx);
36685                 return false;
36686             }
36687         } // isDstOperand
36688
36689         void execute(GPUDynInstPtr) override;
36690     }; // Inst_VOP3__V_CMPX_NLE_F32
36691
36692     class Inst_VOP3__V_CMPX_NEQ_F32 : public Inst_VOP3
36693     {
36694       public:
36695         Inst_VOP3__V_CMPX_NEQ_F32(InFmt_VOP3*);
36696         ~Inst_VOP3__V_CMPX_NEQ_F32();
36697
36698         int
36699         getNumOperands() override
36700         {
36701             return numDstRegOperands() + numSrcRegOperands();
36702         } // getNumOperands
36703
36704         int numDstRegOperands() override { return 1; }
36705         int numSrcRegOperands() override { return 2; }
36706
36707         int
36708         getOperandSize(int opIdx) override
36709         {
36710             switch (opIdx) {
36711               case 0: //src_0
36712                 return 4;
36713               case 1: //src_1
36714                 return 4;
36715               case 2: //sdst
36716                 return 8;
36717               default:
36718                 fatal("op idx %i out of bounds\n", opIdx);
36719                 return -1;
36720             }
36721         } // getOperandSize
36722
36723         bool
36724         isSrcOperand(int opIdx) override
36725         {
36726             switch (opIdx) {
36727               case 0: //src_0
36728                 return true;
36729               case 1: //src_1
36730                 return true;
36731               case 2: //sdst
36732                 return false;
36733               default:
36734                 fatal("op idx %i out of bounds\n", opIdx);
36735                 return false;
36736             }
36737         } // isSrcOperand
36738
36739         bool
36740         isDstOperand(int opIdx) override
36741         {
36742             switch (opIdx) {
36743               case 0: //src_0
36744                 return false;
36745               case 1: //src_1
36746                 return false;
36747               case 2: //sdst
36748                 return true;
36749               default:
36750                 fatal("op idx %i out of bounds\n", opIdx);
36751                 return false;
36752             }
36753         } // isDstOperand
36754
36755         void execute(GPUDynInstPtr) override;
36756     }; // Inst_VOP3__V_CMPX_NEQ_F32
36757
36758     class Inst_VOP3__V_CMPX_NLT_F32 : public Inst_VOP3
36759     {
36760       public:
36761         Inst_VOP3__V_CMPX_NLT_F32(InFmt_VOP3*);
36762         ~Inst_VOP3__V_CMPX_NLT_F32();
36763
36764         int
36765         getNumOperands() override
36766         {
36767             return numDstRegOperands() + numSrcRegOperands();
36768         } // getNumOperands
36769
36770         int numDstRegOperands() override { return 1; }
36771         int numSrcRegOperands() override { return 2; }
36772
36773         int
36774         getOperandSize(int opIdx) override
36775         {
36776             switch (opIdx) {
36777               case 0: //src_0
36778                 return 4;
36779               case 1: //src_1
36780                 return 4;
36781               case 2: //sdst
36782                 return 8;
36783               default:
36784                 fatal("op idx %i out of bounds\n", opIdx);
36785                 return -1;
36786             }
36787         } // getOperandSize
36788
36789         bool
36790         isSrcOperand(int opIdx) override
36791         {
36792             switch (opIdx) {
36793               case 0: //src_0
36794                 return true;
36795               case 1: //src_1
36796                 return true;
36797               case 2: //sdst
36798                 return false;
36799               default:
36800                 fatal("op idx %i out of bounds\n", opIdx);
36801                 return false;
36802             }
36803         } // isSrcOperand
36804
36805         bool
36806         isDstOperand(int opIdx) override
36807         {
36808             switch (opIdx) {
36809               case 0: //src_0
36810                 return false;
36811               case 1: //src_1
36812                 return false;
36813               case 2: //sdst
36814                 return true;
36815               default:
36816                 fatal("op idx %i out of bounds\n", opIdx);
36817                 return false;
36818             }
36819         } // isDstOperand
36820
36821         void execute(GPUDynInstPtr) override;
36822     }; // Inst_VOP3__V_CMPX_NLT_F32
36823
36824     class Inst_VOP3__V_CMPX_TRU_F32 : public Inst_VOP3
36825     {
36826       public:
36827         Inst_VOP3__V_CMPX_TRU_F32(InFmt_VOP3*);
36828         ~Inst_VOP3__V_CMPX_TRU_F32();
36829
36830         int
36831         getNumOperands() override
36832         {
36833             return numDstRegOperands() + numSrcRegOperands();
36834         } // getNumOperands
36835
36836         int numDstRegOperands() override { return 1; }
36837         int numSrcRegOperands() override { return 2; }
36838
36839         int
36840         getOperandSize(int opIdx) override
36841         {
36842             switch (opIdx) {
36843               case 0: //src_0
36844                 return 4;
36845               case 1: //src_1
36846                 return 4;
36847               case 2: //sdst
36848                 return 8;
36849               default:
36850                 fatal("op idx %i out of bounds\n", opIdx);
36851                 return -1;
36852             }
36853         } // getOperandSize
36854
36855         bool
36856         isSrcOperand(int opIdx) override
36857         {
36858             switch (opIdx) {
36859               case 0: //src_0
36860                 return true;
36861               case 1: //src_1
36862                 return true;
36863               case 2: //sdst
36864                 return false;
36865               default:
36866                 fatal("op idx %i out of bounds\n", opIdx);
36867                 return false;
36868             }
36869         } // isSrcOperand
36870
36871         bool
36872         isDstOperand(int opIdx) override
36873         {
36874             switch (opIdx) {
36875               case 0: //src_0
36876                 return false;
36877               case 1: //src_1
36878                 return false;
36879               case 2: //sdst
36880                 return true;
36881               default:
36882                 fatal("op idx %i out of bounds\n", opIdx);
36883                 return false;
36884             }
36885         } // isDstOperand
36886
36887         void execute(GPUDynInstPtr) override;
36888     }; // Inst_VOP3__V_CMPX_TRU_F32
36889
36890     class Inst_VOP3__V_CMP_F_F64 : public Inst_VOP3
36891     {
36892       public:
36893         Inst_VOP3__V_CMP_F_F64(InFmt_VOP3*);
36894         ~Inst_VOP3__V_CMP_F_F64();
36895
36896         int
36897         getNumOperands() override
36898         {
36899             return numDstRegOperands() + numSrcRegOperands();
36900         } // getNumOperands
36901
36902         int numDstRegOperands() override { return 1; }
36903         int numSrcRegOperands() override { return 2; }
36904
36905         int
36906         getOperandSize(int opIdx) override
36907         {
36908             switch (opIdx) {
36909               case 0: //src_0
36910                 return 8;
36911               case 1: //src_1
36912                 return 8;
36913               case 2: //sdst
36914                 return 8;
36915               default:
36916                 fatal("op idx %i out of bounds\n", opIdx);
36917                 return -1;
36918             }
36919         } // getOperandSize
36920
36921         bool
36922         isSrcOperand(int opIdx) override
36923         {
36924             switch (opIdx) {
36925               case 0: //src_0
36926                 return true;
36927               case 1: //src_1
36928                 return true;
36929               case 2: //sdst
36930                 return false;
36931               default:
36932                 fatal("op idx %i out of bounds\n", opIdx);
36933                 return false;
36934             }
36935         } // isSrcOperand
36936
36937         bool
36938         isDstOperand(int opIdx) override
36939         {
36940             switch (opIdx) {
36941               case 0: //src_0
36942                 return false;
36943               case 1: //src_1
36944                 return false;
36945               case 2: //sdst
36946                 return true;
36947               default:
36948                 fatal("op idx %i out of bounds\n", opIdx);
36949                 return false;
36950             }
36951         } // isDstOperand
36952
36953         void execute(GPUDynInstPtr) override;
36954     }; // Inst_VOP3__V_CMP_F_F64
36955
36956     class Inst_VOP3__V_CMP_LT_F64 : public Inst_VOP3
36957     {
36958       public:
36959         Inst_VOP3__V_CMP_LT_F64(InFmt_VOP3*);
36960         ~Inst_VOP3__V_CMP_LT_F64();
36961
36962         int
36963         getNumOperands() override
36964         {
36965             return numDstRegOperands() + numSrcRegOperands();
36966         } // getNumOperands
36967
36968         int numDstRegOperands() override { return 1; }
36969         int numSrcRegOperands() override { return 2; }
36970
36971         int
36972         getOperandSize(int opIdx) override
36973         {
36974             switch (opIdx) {
36975               case 0: //src_0
36976                 return 8;
36977               case 1: //src_1
36978                 return 8;
36979               case 2: //sdst
36980                 return 8;
36981               default:
36982                 fatal("op idx %i out of bounds\n", opIdx);
36983                 return -1;
36984             }
36985         } // getOperandSize
36986
36987         bool
36988         isSrcOperand(int opIdx) override
36989         {
36990             switch (opIdx) {
36991               case 0: //src_0
36992                 return true;
36993               case 1: //src_1
36994                 return true;
36995               case 2: //sdst
36996                 return false;
36997               default:
36998                 fatal("op idx %i out of bounds\n", opIdx);
36999                 return false;
37000             }
37001         } // isSrcOperand
37002
37003         bool
37004         isDstOperand(int opIdx) override
37005         {
37006             switch (opIdx) {
37007               case 0: //src_0
37008                 return false;
37009               case 1: //src_1
37010                 return false;
37011               case 2: //sdst
37012                 return true;
37013               default:
37014                 fatal("op idx %i out of bounds\n", opIdx);
37015                 return false;
37016             }
37017         } // isDstOperand
37018
37019         void execute(GPUDynInstPtr) override;
37020     }; // Inst_VOP3__V_CMP_LT_F64
37021
37022     class Inst_VOP3__V_CMP_EQ_F64 : public Inst_VOP3
37023     {
37024       public:
37025         Inst_VOP3__V_CMP_EQ_F64(InFmt_VOP3*);
37026         ~Inst_VOP3__V_CMP_EQ_F64();
37027
37028         int
37029         getNumOperands() override
37030         {
37031             return numDstRegOperands() + numSrcRegOperands();
37032         } // getNumOperands
37033
37034         int numDstRegOperands() override { return 1; }
37035         int numSrcRegOperands() override { return 2; }
37036
37037         int
37038         getOperandSize(int opIdx) override
37039         {
37040             switch (opIdx) {
37041               case 0: //src_0
37042                 return 8;
37043               case 1: //src_1
37044                 return 8;
37045               case 2: //sdst
37046                 return 8;
37047               default:
37048                 fatal("op idx %i out of bounds\n", opIdx);
37049                 return -1;
37050             }
37051         } // getOperandSize
37052
37053         bool
37054         isSrcOperand(int opIdx) override
37055         {
37056             switch (opIdx) {
37057               case 0: //src_0
37058                 return true;
37059               case 1: //src_1
37060                 return true;
37061               case 2: //sdst
37062                 return false;
37063               default:
37064                 fatal("op idx %i out of bounds\n", opIdx);
37065                 return false;
37066             }
37067         } // isSrcOperand
37068
37069         bool
37070         isDstOperand(int opIdx) override
37071         {
37072             switch (opIdx) {
37073               case 0: //src_0
37074                 return false;
37075               case 1: //src_1
37076                 return false;
37077               case 2: //sdst
37078                 return true;
37079               default:
37080                 fatal("op idx %i out of bounds\n", opIdx);
37081                 return false;
37082             }
37083         } // isDstOperand
37084
37085         void execute(GPUDynInstPtr) override;
37086     }; // Inst_VOP3__V_CMP_EQ_F64
37087
37088     class Inst_VOP3__V_CMP_LE_F64 : public Inst_VOP3
37089     {
37090       public:
37091         Inst_VOP3__V_CMP_LE_F64(InFmt_VOP3*);
37092         ~Inst_VOP3__V_CMP_LE_F64();
37093
37094         int
37095         getNumOperands() override
37096         {
37097             return numDstRegOperands() + numSrcRegOperands();
37098         } // getNumOperands
37099
37100         int numDstRegOperands() override { return 1; }
37101         int numSrcRegOperands() override { return 2; }
37102
37103         int
37104         getOperandSize(int opIdx) override
37105         {
37106             switch (opIdx) {
37107               case 0: //src_0
37108                 return 8;
37109               case 1: //src_1
37110                 return 8;
37111               case 2: //sdst
37112                 return 8;
37113               default:
37114                 fatal("op idx %i out of bounds\n", opIdx);
37115                 return -1;
37116             }
37117         } // getOperandSize
37118
37119         bool
37120         isSrcOperand(int opIdx) override
37121         {
37122             switch (opIdx) {
37123               case 0: //src_0
37124                 return true;
37125               case 1: //src_1
37126                 return true;
37127               case 2: //sdst
37128                 return false;
37129               default:
37130                 fatal("op idx %i out of bounds\n", opIdx);
37131                 return false;
37132             }
37133         } // isSrcOperand
37134
37135         bool
37136         isDstOperand(int opIdx) override
37137         {
37138             switch (opIdx) {
37139               case 0: //src_0
37140                 return false;
37141               case 1: //src_1
37142                 return false;
37143               case 2: //sdst
37144                 return true;
37145               default:
37146                 fatal("op idx %i out of bounds\n", opIdx);
37147                 return false;
37148             }
37149         } // isDstOperand
37150
37151         void execute(GPUDynInstPtr) override;
37152     }; // Inst_VOP3__V_CMP_LE_F64
37153
37154     class Inst_VOP3__V_CMP_GT_F64 : public Inst_VOP3
37155     {
37156       public:
37157         Inst_VOP3__V_CMP_GT_F64(InFmt_VOP3*);
37158         ~Inst_VOP3__V_CMP_GT_F64();
37159
37160         int
37161         getNumOperands() override
37162         {
37163             return numDstRegOperands() + numSrcRegOperands();
37164         } // getNumOperands
37165
37166         int numDstRegOperands() override { return 1; }
37167         int numSrcRegOperands() override { return 2; }
37168
37169         int
37170         getOperandSize(int opIdx) override
37171         {
37172             switch (opIdx) {
37173               case 0: //src_0
37174                 return 8;
37175               case 1: //src_1
37176                 return 8;
37177               case 2: //sdst
37178                 return 8;
37179               default:
37180                 fatal("op idx %i out of bounds\n", opIdx);
37181                 return -1;
37182             }
37183         } // getOperandSize
37184
37185         bool
37186         isSrcOperand(int opIdx) override
37187         {
37188             switch (opIdx) {
37189               case 0: //src_0
37190                 return true;
37191               case 1: //src_1
37192                 return true;
37193               case 2: //sdst
37194                 return false;
37195               default:
37196                 fatal("op idx %i out of bounds\n", opIdx);
37197                 return false;
37198             }
37199         } // isSrcOperand
37200
37201         bool
37202         isDstOperand(int opIdx) override
37203         {
37204             switch (opIdx) {
37205               case 0: //src_0
37206                 return false;
37207               case 1: //src_1
37208                 return false;
37209               case 2: //sdst
37210                 return true;
37211               default:
37212                 fatal("op idx %i out of bounds\n", opIdx);
37213                 return false;
37214             }
37215         } // isDstOperand
37216
37217         void execute(GPUDynInstPtr) override;
37218     }; // Inst_VOP3__V_CMP_GT_F64
37219
37220     class Inst_VOP3__V_CMP_LG_F64 : public Inst_VOP3
37221     {
37222       public:
37223         Inst_VOP3__V_CMP_LG_F64(InFmt_VOP3*);
37224         ~Inst_VOP3__V_CMP_LG_F64();
37225
37226         int
37227         getNumOperands() override
37228         {
37229             return numDstRegOperands() + numSrcRegOperands();
37230         } // getNumOperands
37231
37232         int numDstRegOperands() override { return 1; }
37233         int numSrcRegOperands() override { return 2; }
37234
37235         int
37236         getOperandSize(int opIdx) override
37237         {
37238             switch (opIdx) {
37239               case 0: //src_0
37240                 return 8;
37241               case 1: //src_1
37242                 return 8;
37243               case 2: //sdst
37244                 return 8;
37245               default:
37246                 fatal("op idx %i out of bounds\n", opIdx);
37247                 return -1;
37248             }
37249         } // getOperandSize
37250
37251         bool
37252         isSrcOperand(int opIdx) override
37253         {
37254             switch (opIdx) {
37255               case 0: //src_0
37256                 return true;
37257               case 1: //src_1
37258                 return true;
37259               case 2: //sdst
37260                 return false;
37261               default:
37262                 fatal("op idx %i out of bounds\n", opIdx);
37263                 return false;
37264             }
37265         } // isSrcOperand
37266
37267         bool
37268         isDstOperand(int opIdx) override
37269         {
37270             switch (opIdx) {
37271               case 0: //src_0
37272                 return false;
37273               case 1: //src_1
37274                 return false;
37275               case 2: //sdst
37276                 return true;
37277               default:
37278                 fatal("op idx %i out of bounds\n", opIdx);
37279                 return false;
37280             }
37281         } // isDstOperand
37282
37283         void execute(GPUDynInstPtr) override;
37284     }; // Inst_VOP3__V_CMP_LG_F64
37285
37286     class Inst_VOP3__V_CMP_GE_F64 : public Inst_VOP3
37287     {
37288       public:
37289         Inst_VOP3__V_CMP_GE_F64(InFmt_VOP3*);
37290         ~Inst_VOP3__V_CMP_GE_F64();
37291
37292         int
37293         getNumOperands() override
37294         {
37295             return numDstRegOperands() + numSrcRegOperands();
37296         } // getNumOperands
37297
37298         int numDstRegOperands() override { return 1; }
37299         int numSrcRegOperands() override { return 2; }
37300
37301         int
37302         getOperandSize(int opIdx) override
37303         {
37304             switch (opIdx) {
37305               case 0: //src_0
37306                 return 8;
37307               case 1: //src_1
37308                 return 8;
37309               case 2: //sdst
37310                 return 8;
37311               default:
37312                 fatal("op idx %i out of bounds\n", opIdx);
37313                 return -1;
37314             }
37315         } // getOperandSize
37316
37317         bool
37318         isSrcOperand(int opIdx) override
37319         {
37320             switch (opIdx) {
37321               case 0: //src_0
37322                 return true;
37323               case 1: //src_1
37324                 return true;
37325               case 2: //sdst
37326                 return false;
37327               default:
37328                 fatal("op idx %i out of bounds\n", opIdx);
37329                 return false;
37330             }
37331         } // isSrcOperand
37332
37333         bool
37334         isDstOperand(int opIdx) override
37335         {
37336             switch (opIdx) {
37337               case 0: //src_0
37338                 return false;
37339               case 1: //src_1
37340                 return false;
37341               case 2: //sdst
37342                 return true;
37343               default:
37344                 fatal("op idx %i out of bounds\n", opIdx);
37345                 return false;
37346             }
37347         } // isDstOperand
37348
37349         void execute(GPUDynInstPtr) override;
37350     }; // Inst_VOP3__V_CMP_GE_F64
37351
37352     class Inst_VOP3__V_CMP_O_F64 : public Inst_VOP3
37353     {
37354       public:
37355         Inst_VOP3__V_CMP_O_F64(InFmt_VOP3*);
37356         ~Inst_VOP3__V_CMP_O_F64();
37357
37358         int
37359         getNumOperands() override
37360         {
37361             return numDstRegOperands() + numSrcRegOperands();
37362         } // getNumOperands
37363
37364         int numDstRegOperands() override { return 1; }
37365         int numSrcRegOperands() override { return 2; }
37366
37367         int
37368         getOperandSize(int opIdx) override
37369         {
37370             switch (opIdx) {
37371               case 0: //src_0
37372                 return 8;
37373               case 1: //src_1
37374                 return 8;
37375               case 2: //sdst
37376                 return 8;
37377               default:
37378                 fatal("op idx %i out of bounds\n", opIdx);
37379                 return -1;
37380             }
37381         } // getOperandSize
37382
37383         bool
37384         isSrcOperand(int opIdx) override
37385         {
37386             switch (opIdx) {
37387               case 0: //src_0
37388                 return true;
37389               case 1: //src_1
37390                 return true;
37391               case 2: //sdst
37392                 return false;
37393               default:
37394                 fatal("op idx %i out of bounds\n", opIdx);
37395                 return false;
37396             }
37397         } // isSrcOperand
37398
37399         bool
37400         isDstOperand(int opIdx) override
37401         {
37402             switch (opIdx) {
37403               case 0: //src_0
37404                 return false;
37405               case 1: //src_1
37406                 return false;
37407               case 2: //sdst
37408                 return true;
37409               default:
37410                 fatal("op idx %i out of bounds\n", opIdx);
37411                 return false;
37412             }
37413         } // isDstOperand
37414
37415         void execute(GPUDynInstPtr) override;
37416     }; // Inst_VOP3__V_CMP_O_F64
37417
37418     class Inst_VOP3__V_CMP_U_F64 : public Inst_VOP3
37419     {
37420       public:
37421         Inst_VOP3__V_CMP_U_F64(InFmt_VOP3*);
37422         ~Inst_VOP3__V_CMP_U_F64();
37423
37424         int
37425         getNumOperands() override
37426         {
37427             return numDstRegOperands() + numSrcRegOperands();
37428         } // getNumOperands
37429
37430         int numDstRegOperands() override { return 1; }
37431         int numSrcRegOperands() override { return 2; }
37432
37433         int
37434         getOperandSize(int opIdx) override
37435         {
37436             switch (opIdx) {
37437               case 0: //src_0
37438                 return 8;
37439               case 1: //src_1
37440                 return 8;
37441               case 2: //sdst
37442                 return 8;
37443               default:
37444                 fatal("op idx %i out of bounds\n", opIdx);
37445                 return -1;
37446             }
37447         } // getOperandSize
37448
37449         bool
37450         isSrcOperand(int opIdx) override
37451         {
37452             switch (opIdx) {
37453               case 0: //src_0
37454                 return true;
37455               case 1: //src_1
37456                 return true;
37457               case 2: //sdst
37458                 return false;
37459               default:
37460                 fatal("op idx %i out of bounds\n", opIdx);
37461                 return false;
37462             }
37463         } // isSrcOperand
37464
37465         bool
37466         isDstOperand(int opIdx) override
37467         {
37468             switch (opIdx) {
37469               case 0: //src_0
37470                 return false;
37471               case 1: //src_1
37472                 return false;
37473               case 2: //sdst
37474                 return true;
37475               default:
37476                 fatal("op idx %i out of bounds\n", opIdx);
37477                 return false;
37478             }
37479         } // isDstOperand
37480
37481         void execute(GPUDynInstPtr) override;
37482     }; // Inst_VOP3__V_CMP_U_F64
37483
37484     class Inst_VOP3__V_CMP_NGE_F64 : public Inst_VOP3
37485     {
37486       public:
37487         Inst_VOP3__V_CMP_NGE_F64(InFmt_VOP3*);
37488         ~Inst_VOP3__V_CMP_NGE_F64();
37489
37490         int
37491         getNumOperands() override
37492         {
37493             return numDstRegOperands() + numSrcRegOperands();
37494         } // getNumOperands
37495
37496         int numDstRegOperands() override { return 1; }
37497         int numSrcRegOperands() override { return 2; }
37498
37499         int
37500         getOperandSize(int opIdx) override
37501         {
37502             switch (opIdx) {
37503               case 0: //src_0
37504                 return 8;
37505               case 1: //src_1
37506                 return 8;
37507               case 2: //sdst
37508                 return 8;
37509               default:
37510                 fatal("op idx %i out of bounds\n", opIdx);
37511                 return -1;
37512             }
37513         } // getOperandSize
37514
37515         bool
37516         isSrcOperand(int opIdx) override
37517         {
37518             switch (opIdx) {
37519               case 0: //src_0
37520                 return true;
37521               case 1: //src_1
37522                 return true;
37523               case 2: //sdst
37524                 return false;
37525               default:
37526                 fatal("op idx %i out of bounds\n", opIdx);
37527                 return false;
37528             }
37529         } // isSrcOperand
37530
37531         bool
37532         isDstOperand(int opIdx) override
37533         {
37534             switch (opIdx) {
37535               case 0: //src_0
37536                 return false;
37537               case 1: //src_1
37538                 return false;
37539               case 2: //sdst
37540                 return true;
37541               default:
37542                 fatal("op idx %i out of bounds\n", opIdx);
37543                 return false;
37544             }
37545         } // isDstOperand
37546
37547         void execute(GPUDynInstPtr) override;
37548     }; // Inst_VOP3__V_CMP_NGE_F64
37549
37550     class Inst_VOP3__V_CMP_NLG_F64 : public Inst_VOP3
37551     {
37552       public:
37553         Inst_VOP3__V_CMP_NLG_F64(InFmt_VOP3*);
37554         ~Inst_VOP3__V_CMP_NLG_F64();
37555
37556         int
37557         getNumOperands() override
37558         {
37559             return numDstRegOperands() + numSrcRegOperands();
37560         } // getNumOperands
37561
37562         int numDstRegOperands() override { return 1; }
37563         int numSrcRegOperands() override { return 2; }
37564
37565         int
37566         getOperandSize(int opIdx) override
37567         {
37568             switch (opIdx) {
37569               case 0: //src_0
37570                 return 8;
37571               case 1: //src_1
37572                 return 8;
37573               case 2: //sdst
37574                 return 8;
37575               default:
37576                 fatal("op idx %i out of bounds\n", opIdx);
37577                 return -1;
37578             }
37579         } // getOperandSize
37580
37581         bool
37582         isSrcOperand(int opIdx) override
37583         {
37584             switch (opIdx) {
37585               case 0: //src_0
37586                 return true;
37587               case 1: //src_1
37588                 return true;
37589               case 2: //sdst
37590                 return false;
37591               default:
37592                 fatal("op idx %i out of bounds\n", opIdx);
37593                 return false;
37594             }
37595         } // isSrcOperand
37596
37597         bool
37598         isDstOperand(int opIdx) override
37599         {
37600             switch (opIdx) {
37601               case 0: //src_0
37602                 return false;
37603               case 1: //src_1
37604                 return false;
37605               case 2: //sdst
37606                 return true;
37607               default:
37608                 fatal("op idx %i out of bounds\n", opIdx);
37609                 return false;
37610             }
37611         } // isDstOperand
37612
37613         void execute(GPUDynInstPtr) override;
37614     }; // Inst_VOP3__V_CMP_NLG_F64
37615
37616     class Inst_VOP3__V_CMP_NGT_F64 : public Inst_VOP3
37617     {
37618       public:
37619         Inst_VOP3__V_CMP_NGT_F64(InFmt_VOP3*);
37620         ~Inst_VOP3__V_CMP_NGT_F64();
37621
37622         int
37623         getNumOperands() override
37624         {
37625             return numDstRegOperands() + numSrcRegOperands();
37626         } // getNumOperands
37627
37628         int numDstRegOperands() override { return 1; }
37629         int numSrcRegOperands() override { return 2; }
37630
37631         int
37632         getOperandSize(int opIdx) override
37633         {
37634             switch (opIdx) {
37635               case 0: //src_0
37636                 return 8;
37637               case 1: //src_1
37638                 return 8;
37639               case 2: //sdst
37640                 return 8;
37641               default:
37642                 fatal("op idx %i out of bounds\n", opIdx);
37643                 return -1;
37644             }
37645         } // getOperandSize
37646
37647         bool
37648         isSrcOperand(int opIdx) override
37649         {
37650             switch (opIdx) {
37651               case 0: //src_0
37652                 return true;
37653               case 1: //src_1
37654                 return true;
37655               case 2: //sdst
37656                 return false;
37657               default:
37658                 fatal("op idx %i out of bounds\n", opIdx);
37659                 return false;
37660             }
37661         } // isSrcOperand
37662
37663         bool
37664         isDstOperand(int opIdx) override
37665         {
37666             switch (opIdx) {
37667               case 0: //src_0
37668                 return false;
37669               case 1: //src_1
37670                 return false;
37671               case 2: //sdst
37672                 return true;
37673               default:
37674                 fatal("op idx %i out of bounds\n", opIdx);
37675                 return false;
37676             }
37677         } // isDstOperand
37678
37679         void execute(GPUDynInstPtr) override;
37680     }; // Inst_VOP3__V_CMP_NGT_F64
37681
37682     class Inst_VOP3__V_CMP_NLE_F64 : public Inst_VOP3
37683     {
37684       public:
37685         Inst_VOP3__V_CMP_NLE_F64(InFmt_VOP3*);
37686         ~Inst_VOP3__V_CMP_NLE_F64();
37687
37688         int
37689         getNumOperands() override
37690         {
37691             return numDstRegOperands() + numSrcRegOperands();
37692         } // getNumOperands
37693
37694         int numDstRegOperands() override { return 1; }
37695         int numSrcRegOperands() override { return 2; }
37696
37697         int
37698         getOperandSize(int opIdx) override
37699         {
37700             switch (opIdx) {
37701               case 0: //src_0
37702                 return 8;
37703               case 1: //src_1
37704                 return 8;
37705               case 2: //sdst
37706                 return 8;
37707               default:
37708                 fatal("op idx %i out of bounds\n", opIdx);
37709                 return -1;
37710             }
37711         } // getOperandSize
37712
37713         bool
37714         isSrcOperand(int opIdx) override
37715         {
37716             switch (opIdx) {
37717               case 0: //src_0
37718                 return true;
37719               case 1: //src_1
37720                 return true;
37721               case 2: //sdst
37722                 return false;
37723               default:
37724                 fatal("op idx %i out of bounds\n", opIdx);
37725                 return false;
37726             }
37727         } // isSrcOperand
37728
37729         bool
37730         isDstOperand(int opIdx) override
37731         {
37732             switch (opIdx) {
37733               case 0: //src_0
37734                 return false;
37735               case 1: //src_1
37736                 return false;
37737               case 2: //sdst
37738                 return true;
37739               default:
37740                 fatal("op idx %i out of bounds\n", opIdx);
37741                 return false;
37742             }
37743         } // isDstOperand
37744
37745         void execute(GPUDynInstPtr) override;
37746     }; // Inst_VOP3__V_CMP_NLE_F64
37747
37748     class Inst_VOP3__V_CMP_NEQ_F64 : public Inst_VOP3
37749     {
37750       public:
37751         Inst_VOP3__V_CMP_NEQ_F64(InFmt_VOP3*);
37752         ~Inst_VOP3__V_CMP_NEQ_F64();
37753
37754         int
37755         getNumOperands() override
37756         {
37757             return numDstRegOperands() + numSrcRegOperands();
37758         } // getNumOperands
37759
37760         int numDstRegOperands() override { return 1; }
37761         int numSrcRegOperands() override { return 2; }
37762
37763         int
37764         getOperandSize(int opIdx) override
37765         {
37766             switch (opIdx) {
37767               case 0: //src_0
37768                 return 8;
37769               case 1: //src_1
37770                 return 8;
37771               case 2: //sdst
37772                 return 8;
37773               default:
37774                 fatal("op idx %i out of bounds\n", opIdx);
37775                 return -1;
37776             }
37777         } // getOperandSize
37778
37779         bool
37780         isSrcOperand(int opIdx) override
37781         {
37782             switch (opIdx) {
37783               case 0: //src_0
37784                 return true;
37785               case 1: //src_1
37786                 return true;
37787               case 2: //sdst
37788                 return false;
37789               default:
37790                 fatal("op idx %i out of bounds\n", opIdx);
37791                 return false;
37792             }
37793         } // isSrcOperand
37794
37795         bool
37796         isDstOperand(int opIdx) override
37797         {
37798             switch (opIdx) {
37799               case 0: //src_0
37800                 return false;
37801               case 1: //src_1
37802                 return false;
37803               case 2: //sdst
37804                 return true;
37805               default:
37806                 fatal("op idx %i out of bounds\n", opIdx);
37807                 return false;
37808             }
37809         } // isDstOperand
37810
37811         void execute(GPUDynInstPtr) override;
37812     }; // Inst_VOP3__V_CMP_NEQ_F64
37813
37814     class Inst_VOP3__V_CMP_NLT_F64 : public Inst_VOP3
37815     {
37816       public:
37817         Inst_VOP3__V_CMP_NLT_F64(InFmt_VOP3*);
37818         ~Inst_VOP3__V_CMP_NLT_F64();
37819
37820         int
37821         getNumOperands() override
37822         {
37823             return numDstRegOperands() + numSrcRegOperands();
37824         } // getNumOperands
37825
37826         int numDstRegOperands() override { return 1; }
37827         int numSrcRegOperands() override { return 2; }
37828
37829         int
37830         getOperandSize(int opIdx) override
37831         {
37832             switch (opIdx) {
37833               case 0: //src_0
37834                 return 8;
37835               case 1: //src_1
37836                 return 8;
37837               case 2: //sdst
37838                 return 8;
37839               default:
37840                 fatal("op idx %i out of bounds\n", opIdx);
37841                 return -1;
37842             }
37843         } // getOperandSize
37844
37845         bool
37846         isSrcOperand(int opIdx) override
37847         {
37848             switch (opIdx) {
37849               case 0: //src_0
37850                 return true;
37851               case 1: //src_1
37852                 return true;
37853               case 2: //sdst
37854                 return false;
37855               default:
37856                 fatal("op idx %i out of bounds\n", opIdx);
37857                 return false;
37858             }
37859         } // isSrcOperand
37860
37861         bool
37862         isDstOperand(int opIdx) override
37863         {
37864             switch (opIdx) {
37865               case 0: //src_0
37866                 return false;
37867               case 1: //src_1
37868                 return false;
37869               case 2: //sdst
37870                 return true;
37871               default:
37872                 fatal("op idx %i out of bounds\n", opIdx);
37873                 return false;
37874             }
37875         } // isDstOperand
37876
37877         void execute(GPUDynInstPtr) override;
37878     }; // Inst_VOP3__V_CMP_NLT_F64
37879
37880     class Inst_VOP3__V_CMP_TRU_F64 : public Inst_VOP3
37881     {
37882       public:
37883         Inst_VOP3__V_CMP_TRU_F64(InFmt_VOP3*);
37884         ~Inst_VOP3__V_CMP_TRU_F64();
37885
37886         int
37887         getNumOperands() override
37888         {
37889             return numDstRegOperands() + numSrcRegOperands();
37890         } // getNumOperands
37891
37892         int numDstRegOperands() override { return 1; }
37893         int numSrcRegOperands() override { return 2; }
37894
37895         int
37896         getOperandSize(int opIdx) override
37897         {
37898             switch (opIdx) {
37899               case 0: //src_0
37900                 return 8;
37901               case 1: //src_1
37902                 return 8;
37903               case 2: //sdst
37904                 return 8;
37905               default:
37906                 fatal("op idx %i out of bounds\n", opIdx);
37907                 return -1;
37908             }
37909         } // getOperandSize
37910
37911         bool
37912         isSrcOperand(int opIdx) override
37913         {
37914             switch (opIdx) {
37915               case 0: //src_0
37916                 return true;
37917               case 1: //src_1
37918                 return true;
37919               case 2: //sdst
37920                 return false;
37921               default:
37922                 fatal("op idx %i out of bounds\n", opIdx);
37923                 return false;
37924             }
37925         } // isSrcOperand
37926
37927         bool
37928         isDstOperand(int opIdx) override
37929         {
37930             switch (opIdx) {
37931               case 0: //src_0
37932                 return false;
37933               case 1: //src_1
37934                 return false;
37935               case 2: //sdst
37936                 return true;
37937               default:
37938                 fatal("op idx %i out of bounds\n", opIdx);
37939                 return false;
37940             }
37941         } // isDstOperand
37942
37943         void execute(GPUDynInstPtr) override;
37944     }; // Inst_VOP3__V_CMP_TRU_F64
37945
37946     class Inst_VOP3__V_CMPX_F_F64 : public Inst_VOP3
37947     {
37948       public:
37949         Inst_VOP3__V_CMPX_F_F64(InFmt_VOP3*);
37950         ~Inst_VOP3__V_CMPX_F_F64();
37951
37952         int
37953         getNumOperands() override
37954         {
37955             return numDstRegOperands() + numSrcRegOperands();
37956         } // getNumOperands
37957
37958         int numDstRegOperands() override { return 1; }
37959         int numSrcRegOperands() override { return 2; }
37960
37961         int
37962         getOperandSize(int opIdx) override
37963         {
37964             switch (opIdx) {
37965               case 0: //src_0
37966                 return 8;
37967               case 1: //src_1
37968                 return 8;
37969               case 2: //sdst
37970                 return 8;
37971               default:
37972                 fatal("op idx %i out of bounds\n", opIdx);
37973                 return -1;
37974             }
37975         } // getOperandSize
37976
37977         bool
37978         isSrcOperand(int opIdx) override
37979         {
37980             switch (opIdx) {
37981               case 0: //src_0
37982                 return true;
37983               case 1: //src_1
37984                 return true;
37985               case 2: //sdst
37986                 return false;
37987               default:
37988                 fatal("op idx %i out of bounds\n", opIdx);
37989                 return false;
37990             }
37991         } // isSrcOperand
37992
37993         bool
37994         isDstOperand(int opIdx) override
37995         {
37996             switch (opIdx) {
37997               case 0: //src_0
37998                 return false;
37999               case 1: //src_1
38000                 return false;
38001               case 2: //sdst
38002                 return true;
38003               default:
38004                 fatal("op idx %i out of bounds\n", opIdx);
38005                 return false;
38006             }
38007         } // isDstOperand
38008
38009         void execute(GPUDynInstPtr) override;
38010     }; // Inst_VOP3__V_CMPX_F_F64
38011
38012     class Inst_VOP3__V_CMPX_LT_F64 : public Inst_VOP3
38013     {
38014       public:
38015         Inst_VOP3__V_CMPX_LT_F64(InFmt_VOP3*);
38016         ~Inst_VOP3__V_CMPX_LT_F64();
38017
38018         int
38019         getNumOperands() override
38020         {
38021             return numDstRegOperands() + numSrcRegOperands();
38022         } // getNumOperands
38023
38024         int numDstRegOperands() override { return 1; }
38025         int numSrcRegOperands() override { return 2; }
38026
38027         int
38028         getOperandSize(int opIdx) override
38029         {
38030             switch (opIdx) {
38031               case 0: //src_0
38032                 return 8;
38033               case 1: //src_1
38034                 return 8;
38035               case 2: //sdst
38036                 return 8;
38037               default:
38038                 fatal("op idx %i out of bounds\n", opIdx);
38039                 return -1;
38040             }
38041         } // getOperandSize
38042
38043         bool
38044         isSrcOperand(int opIdx) override
38045         {
38046             switch (opIdx) {
38047               case 0: //src_0
38048                 return true;
38049               case 1: //src_1
38050                 return true;
38051               case 2: //sdst
38052                 return false;
38053               default:
38054                 fatal("op idx %i out of bounds\n", opIdx);
38055                 return false;
38056             }
38057         } // isSrcOperand
38058
38059         bool
38060         isDstOperand(int opIdx) override
38061         {
38062             switch (opIdx) {
38063               case 0: //src_0
38064                 return false;
38065               case 1: //src_1
38066                 return false;
38067               case 2: //sdst
38068                 return true;
38069               default:
38070                 fatal("op idx %i out of bounds\n", opIdx);
38071                 return false;
38072             }
38073         } // isDstOperand
38074
38075         void execute(GPUDynInstPtr) override;
38076     }; // Inst_VOP3__V_CMPX_LT_F64
38077
38078     class Inst_VOP3__V_CMPX_EQ_F64 : public Inst_VOP3
38079     {
38080       public:
38081         Inst_VOP3__V_CMPX_EQ_F64(InFmt_VOP3*);
38082         ~Inst_VOP3__V_CMPX_EQ_F64();
38083
38084         int
38085         getNumOperands() override
38086         {
38087             return numDstRegOperands() + numSrcRegOperands();
38088         } // getNumOperands
38089
38090         int numDstRegOperands() override { return 1; }
38091         int numSrcRegOperands() override { return 2; }
38092
38093         int
38094         getOperandSize(int opIdx) override
38095         {
38096             switch (opIdx) {
38097               case 0: //src_0
38098                 return 8;
38099               case 1: //src_1
38100                 return 8;
38101               case 2: //sdst
38102                 return 8;
38103               default:
38104                 fatal("op idx %i out of bounds\n", opIdx);
38105                 return -1;
38106             }
38107         } // getOperandSize
38108
38109         bool
38110         isSrcOperand(int opIdx) override
38111         {
38112             switch (opIdx) {
38113               case 0: //src_0
38114                 return true;
38115               case 1: //src_1
38116                 return true;
38117               case 2: //sdst
38118                 return false;
38119               default:
38120                 fatal("op idx %i out of bounds\n", opIdx);
38121                 return false;
38122             }
38123         } // isSrcOperand
38124
38125         bool
38126         isDstOperand(int opIdx) override
38127         {
38128             switch (opIdx) {
38129               case 0: //src_0
38130                 return false;
38131               case 1: //src_1
38132                 return false;
38133               case 2: //sdst
38134                 return true;
38135               default:
38136                 fatal("op idx %i out of bounds\n", opIdx);
38137                 return false;
38138             }
38139         } // isDstOperand
38140
38141         void execute(GPUDynInstPtr) override;
38142     }; // Inst_VOP3__V_CMPX_EQ_F64
38143
38144     class Inst_VOP3__V_CMPX_LE_F64 : public Inst_VOP3
38145     {
38146       public:
38147         Inst_VOP3__V_CMPX_LE_F64(InFmt_VOP3*);
38148         ~Inst_VOP3__V_CMPX_LE_F64();
38149
38150         int
38151         getNumOperands() override
38152         {
38153             return numDstRegOperands() + numSrcRegOperands();
38154         } // getNumOperands
38155
38156         int numDstRegOperands() override { return 1; }
38157         int numSrcRegOperands() override { return 2; }
38158
38159         int
38160         getOperandSize(int opIdx) override
38161         {
38162             switch (opIdx) {
38163               case 0: //src_0
38164                 return 8;
38165               case 1: //src_1
38166                 return 8;
38167               case 2: //sdst
38168                 return 8;
38169               default:
38170                 fatal("op idx %i out of bounds\n", opIdx);
38171                 return -1;
38172             }
38173         } // getOperandSize
38174
38175         bool
38176         isSrcOperand(int opIdx) override
38177         {
38178             switch (opIdx) {
38179               case 0: //src_0
38180                 return true;
38181               case 1: //src_1
38182                 return true;
38183               case 2: //sdst
38184                 return false;
38185               default:
38186                 fatal("op idx %i out of bounds\n", opIdx);
38187                 return false;
38188             }
38189         } // isSrcOperand
38190
38191         bool
38192         isDstOperand(int opIdx) override
38193         {
38194             switch (opIdx) {
38195               case 0: //src_0
38196                 return false;
38197               case 1: //src_1
38198                 return false;
38199               case 2: //sdst
38200                 return true;
38201               default:
38202                 fatal("op idx %i out of bounds\n", opIdx);
38203                 return false;
38204             }
38205         } // isDstOperand
38206
38207         void execute(GPUDynInstPtr) override;
38208     }; // Inst_VOP3__V_CMPX_LE_F64
38209
38210     class Inst_VOP3__V_CMPX_GT_F64 : public Inst_VOP3
38211     {
38212       public:
38213         Inst_VOP3__V_CMPX_GT_F64(InFmt_VOP3*);
38214         ~Inst_VOP3__V_CMPX_GT_F64();
38215
38216         int
38217         getNumOperands() override
38218         {
38219             return numDstRegOperands() + numSrcRegOperands();
38220         } // getNumOperands
38221
38222         int numDstRegOperands() override { return 1; }
38223         int numSrcRegOperands() override { return 2; }
38224
38225         int
38226         getOperandSize(int opIdx) override
38227         {
38228             switch (opIdx) {
38229               case 0: //src_0
38230                 return 8;
38231               case 1: //src_1
38232                 return 8;
38233               case 2: //sdst
38234                 return 8;
38235               default:
38236                 fatal("op idx %i out of bounds\n", opIdx);
38237                 return -1;
38238             }
38239         } // getOperandSize
38240
38241         bool
38242         isSrcOperand(int opIdx) override
38243         {
38244             switch (opIdx) {
38245               case 0: //src_0
38246                 return true;
38247               case 1: //src_1
38248                 return true;
38249               case 2: //sdst
38250                 return false;
38251               default:
38252                 fatal("op idx %i out of bounds\n", opIdx);
38253                 return false;
38254             }
38255         } // isSrcOperand
38256
38257         bool
38258         isDstOperand(int opIdx) override
38259         {
38260             switch (opIdx) {
38261               case 0: //src_0
38262                 return false;
38263               case 1: //src_1
38264                 return false;
38265               case 2: //sdst
38266                 return true;
38267               default:
38268                 fatal("op idx %i out of bounds\n", opIdx);
38269                 return false;
38270             }
38271         } // isDstOperand
38272
38273         void execute(GPUDynInstPtr) override;
38274     }; // Inst_VOP3__V_CMPX_GT_F64
38275
38276     class Inst_VOP3__V_CMPX_LG_F64 : public Inst_VOP3
38277     {
38278       public:
38279         Inst_VOP3__V_CMPX_LG_F64(InFmt_VOP3*);
38280         ~Inst_VOP3__V_CMPX_LG_F64();
38281
38282         int
38283         getNumOperands() override
38284         {
38285             return numDstRegOperands() + numSrcRegOperands();
38286         } // getNumOperands
38287
38288         int numDstRegOperands() override { return 1; }
38289         int numSrcRegOperands() override { return 2; }
38290
38291         int
38292         getOperandSize(int opIdx) override
38293         {
38294             switch (opIdx) {
38295               case 0: //src_0
38296                 return 8;
38297               case 1: //src_1
38298                 return 8;
38299               case 2: //sdst
38300                 return 8;
38301               default:
38302                 fatal("op idx %i out of bounds\n", opIdx);
38303                 return -1;
38304             }
38305         } // getOperandSize
38306
38307         bool
38308         isSrcOperand(int opIdx) override
38309         {
38310             switch (opIdx) {
38311               case 0: //src_0
38312                 return true;
38313               case 1: //src_1
38314                 return true;
38315               case 2: //sdst
38316                 return false;
38317               default:
38318                 fatal("op idx %i out of bounds\n", opIdx);
38319                 return false;
38320             }
38321         } // isSrcOperand
38322
38323         bool
38324         isDstOperand(int opIdx) override
38325         {
38326             switch (opIdx) {
38327               case 0: //src_0
38328                 return false;
38329               case 1: //src_1
38330                 return false;
38331               case 2: //sdst
38332                 return true;
38333               default:
38334                 fatal("op idx %i out of bounds\n", opIdx);
38335                 return false;
38336             }
38337         } // isDstOperand
38338
38339         void execute(GPUDynInstPtr) override;
38340     }; // Inst_VOP3__V_CMPX_LG_F64
38341
38342     class Inst_VOP3__V_CMPX_GE_F64 : public Inst_VOP3
38343     {
38344       public:
38345         Inst_VOP3__V_CMPX_GE_F64(InFmt_VOP3*);
38346         ~Inst_VOP3__V_CMPX_GE_F64();
38347
38348         int
38349         getNumOperands() override
38350         {
38351             return numDstRegOperands() + numSrcRegOperands();
38352         } // getNumOperands
38353
38354         int numDstRegOperands() override { return 1; }
38355         int numSrcRegOperands() override { return 2; }
38356
38357         int
38358         getOperandSize(int opIdx) override
38359         {
38360             switch (opIdx) {
38361               case 0: //src_0
38362                 return 8;
38363               case 1: //src_1
38364                 return 8;
38365               case 2: //sdst
38366                 return 8;
38367               default:
38368                 fatal("op idx %i out of bounds\n", opIdx);
38369                 return -1;
38370             }
38371         } // getOperandSize
38372
38373         bool
38374         isSrcOperand(int opIdx) override
38375         {
38376             switch (opIdx) {
38377               case 0: //src_0
38378                 return true;
38379               case 1: //src_1
38380                 return true;
38381               case 2: //sdst
38382                 return false;
38383               default:
38384                 fatal("op idx %i out of bounds\n", opIdx);
38385                 return false;
38386             }
38387         } // isSrcOperand
38388
38389         bool
38390         isDstOperand(int opIdx) override
38391         {
38392             switch (opIdx) {
38393               case 0: //src_0
38394                 return false;
38395               case 1: //src_1
38396                 return false;
38397               case 2: //sdst
38398                 return true;
38399               default:
38400                 fatal("op idx %i out of bounds\n", opIdx);
38401                 return false;
38402             }
38403         } // isDstOperand
38404
38405         void execute(GPUDynInstPtr) override;
38406     }; // Inst_VOP3__V_CMPX_GE_F64
38407
38408     class Inst_VOP3__V_CMPX_O_F64 : public Inst_VOP3
38409     {
38410       public:
38411         Inst_VOP3__V_CMPX_O_F64(InFmt_VOP3*);
38412         ~Inst_VOP3__V_CMPX_O_F64();
38413
38414         int
38415         getNumOperands() override
38416         {
38417             return numDstRegOperands() + numSrcRegOperands();
38418         } // getNumOperands
38419
38420         int numDstRegOperands() override { return 1; }
38421         int numSrcRegOperands() override { return 2; }
38422
38423         int
38424         getOperandSize(int opIdx) override
38425         {
38426             switch (opIdx) {
38427               case 0: //src_0
38428                 return 8;
38429               case 1: //src_1
38430                 return 8;
38431               case 2: //sdst
38432                 return 8;
38433               default:
38434                 fatal("op idx %i out of bounds\n", opIdx);
38435                 return -1;
38436             }
38437         } // getOperandSize
38438
38439         bool
38440         isSrcOperand(int opIdx) override
38441         {
38442             switch (opIdx) {
38443               case 0: //src_0
38444                 return true;
38445               case 1: //src_1
38446                 return true;
38447               case 2: //sdst
38448                 return false;
38449               default:
38450                 fatal("op idx %i out of bounds\n", opIdx);
38451                 return false;
38452             }
38453         } // isSrcOperand
38454
38455         bool
38456         isDstOperand(int opIdx) override
38457         {
38458             switch (opIdx) {
38459               case 0: //src_0
38460                 return false;
38461               case 1: //src_1
38462                 return false;
38463               case 2: //sdst
38464                 return true;
38465               default:
38466                 fatal("op idx %i out of bounds\n", opIdx);
38467                 return false;
38468             }
38469         } // isDstOperand
38470
38471         void execute(GPUDynInstPtr) override;
38472     }; // Inst_VOP3__V_CMPX_O_F64
38473
38474     class Inst_VOP3__V_CMPX_U_F64 : public Inst_VOP3
38475     {
38476       public:
38477         Inst_VOP3__V_CMPX_U_F64(InFmt_VOP3*);
38478         ~Inst_VOP3__V_CMPX_U_F64();
38479
38480         int
38481         getNumOperands() override
38482         {
38483             return numDstRegOperands() + numSrcRegOperands();
38484         } // getNumOperands
38485
38486         int numDstRegOperands() override { return 1; }
38487         int numSrcRegOperands() override { return 2; }
38488
38489         int
38490         getOperandSize(int opIdx) override
38491         {
38492             switch (opIdx) {
38493               case 0: //src_0
38494                 return 8;
38495               case 1: //src_1
38496                 return 8;
38497               case 2: //sdst
38498                 return 8;
38499               default:
38500                 fatal("op idx %i out of bounds\n", opIdx);
38501                 return -1;
38502             }
38503         } // getOperandSize
38504
38505         bool
38506         isSrcOperand(int opIdx) override
38507         {
38508             switch (opIdx) {
38509               case 0: //src_0
38510                 return true;
38511               case 1: //src_1
38512                 return true;
38513               case 2: //sdst
38514                 return false;
38515               default:
38516                 fatal("op idx %i out of bounds\n", opIdx);
38517                 return false;
38518             }
38519         } // isSrcOperand
38520
38521         bool
38522         isDstOperand(int opIdx) override
38523         {
38524             switch (opIdx) {
38525               case 0: //src_0
38526                 return false;
38527               case 1: //src_1
38528                 return false;
38529               case 2: //sdst
38530                 return true;
38531               default:
38532                 fatal("op idx %i out of bounds\n", opIdx);
38533                 return false;
38534             }
38535         } // isDstOperand
38536
38537         void execute(GPUDynInstPtr) override;
38538     }; // Inst_VOP3__V_CMPX_U_F64
38539
38540     class Inst_VOP3__V_CMPX_NGE_F64 : public Inst_VOP3
38541     {
38542       public:
38543         Inst_VOP3__V_CMPX_NGE_F64(InFmt_VOP3*);
38544         ~Inst_VOP3__V_CMPX_NGE_F64();
38545
38546         int
38547         getNumOperands() override
38548         {
38549             return numDstRegOperands() + numSrcRegOperands();
38550         } // getNumOperands
38551
38552         int numDstRegOperands() override { return 1; }
38553         int numSrcRegOperands() override { return 2; }
38554
38555         int
38556         getOperandSize(int opIdx) override
38557         {
38558             switch (opIdx) {
38559               case 0: //src_0
38560                 return 8;
38561               case 1: //src_1
38562                 return 8;
38563               case 2: //sdst
38564                 return 8;
38565               default:
38566                 fatal("op idx %i out of bounds\n", opIdx);
38567                 return -1;
38568             }
38569         } // getOperandSize
38570
38571         bool
38572         isSrcOperand(int opIdx) override
38573         {
38574             switch (opIdx) {
38575               case 0: //src_0
38576                 return true;
38577               case 1: //src_1
38578                 return true;
38579               case 2: //sdst
38580                 return false;
38581               default:
38582                 fatal("op idx %i out of bounds\n", opIdx);
38583                 return false;
38584             }
38585         } // isSrcOperand
38586
38587         bool
38588         isDstOperand(int opIdx) override
38589         {
38590             switch (opIdx) {
38591               case 0: //src_0
38592                 return false;
38593               case 1: //src_1
38594                 return false;
38595               case 2: //sdst
38596                 return true;
38597               default:
38598                 fatal("op idx %i out of bounds\n", opIdx);
38599                 return false;
38600             }
38601         } // isDstOperand
38602
38603         void execute(GPUDynInstPtr) override;
38604     }; // Inst_VOP3__V_CMPX_NGE_F64
38605
38606     class Inst_VOP3__V_CMPX_NLG_F64 : public Inst_VOP3
38607     {
38608       public:
38609         Inst_VOP3__V_CMPX_NLG_F64(InFmt_VOP3*);
38610         ~Inst_VOP3__V_CMPX_NLG_F64();
38611
38612         int
38613         getNumOperands() override
38614         {
38615             return numDstRegOperands() + numSrcRegOperands();
38616         } // getNumOperands
38617
38618         int numDstRegOperands() override { return 1; }
38619         int numSrcRegOperands() override { return 2; }
38620
38621         int
38622         getOperandSize(int opIdx) override
38623         {
38624             switch (opIdx) {
38625               case 0: //src_0
38626                 return 8;
38627               case 1: //src_1
38628                 return 8;
38629               case 2: //sdst
38630                 return 8;
38631               default:
38632                 fatal("op idx %i out of bounds\n", opIdx);
38633                 return -1;
38634             }
38635         } // getOperandSize
38636
38637         bool
38638         isSrcOperand(int opIdx) override
38639         {
38640             switch (opIdx) {
38641               case 0: //src_0
38642                 return true;
38643               case 1: //src_1
38644                 return true;
38645               case 2: //sdst
38646                 return false;
38647               default:
38648                 fatal("op idx %i out of bounds\n", opIdx);
38649                 return false;
38650             }
38651         } // isSrcOperand
38652
38653         bool
38654         isDstOperand(int opIdx) override
38655         {
38656             switch (opIdx) {
38657               case 0: //src_0
38658                 return false;
38659               case 1: //src_1
38660                 return false;
38661               case 2: //sdst
38662                 return true;
38663               default:
38664                 fatal("op idx %i out of bounds\n", opIdx);
38665                 return false;
38666             }
38667         } // isDstOperand
38668
38669         void execute(GPUDynInstPtr) override;
38670     }; // Inst_VOP3__V_CMPX_NLG_F64
38671
38672     class Inst_VOP3__V_CMPX_NGT_F64 : public Inst_VOP3
38673     {
38674       public:
38675         Inst_VOP3__V_CMPX_NGT_F64(InFmt_VOP3*);
38676         ~Inst_VOP3__V_CMPX_NGT_F64();
38677
38678         int
38679         getNumOperands() override
38680         {
38681             return numDstRegOperands() + numSrcRegOperands();
38682         } // getNumOperands
38683
38684         int numDstRegOperands() override { return 1; }
38685         int numSrcRegOperands() override { return 2; }
38686
38687         int
38688         getOperandSize(int opIdx) override
38689         {
38690             switch (opIdx) {
38691               case 0: //src_0
38692                 return 8;
38693               case 1: //src_1
38694                 return 8;
38695               case 2: //sdst
38696                 return 8;
38697               default:
38698                 fatal("op idx %i out of bounds\n", opIdx);
38699                 return -1;
38700             }
38701         } // getOperandSize
38702
38703         bool
38704         isSrcOperand(int opIdx) override
38705         {
38706             switch (opIdx) {
38707               case 0: //src_0
38708                 return true;
38709               case 1: //src_1
38710                 return true;
38711               case 2: //sdst
38712                 return false;
38713               default:
38714                 fatal("op idx %i out of bounds\n", opIdx);
38715                 return false;
38716             }
38717         } // isSrcOperand
38718
38719         bool
38720         isDstOperand(int opIdx) override
38721         {
38722             switch (opIdx) {
38723               case 0: //src_0
38724                 return false;
38725               case 1: //src_1
38726                 return false;
38727               case 2: //sdst
38728                 return true;
38729               default:
38730                 fatal("op idx %i out of bounds\n", opIdx);
38731                 return false;
38732             }
38733         } // isDstOperand
38734
38735         void execute(GPUDynInstPtr) override;
38736     }; // Inst_VOP3__V_CMPX_NGT_F64
38737
38738     class Inst_VOP3__V_CMPX_NLE_F64 : public Inst_VOP3
38739     {
38740       public:
38741         Inst_VOP3__V_CMPX_NLE_F64(InFmt_VOP3*);
38742         ~Inst_VOP3__V_CMPX_NLE_F64();
38743
38744         int
38745         getNumOperands() override
38746         {
38747             return numDstRegOperands() + numSrcRegOperands();
38748         } // getNumOperands
38749
38750         int numDstRegOperands() override { return 1; }
38751         int numSrcRegOperands() override { return 2; }
38752
38753         int
38754         getOperandSize(int opIdx) override
38755         {
38756             switch (opIdx) {
38757               case 0: //src_0
38758                 return 8;
38759               case 1: //src_1
38760                 return 8;
38761               case 2: //sdst
38762                 return 8;
38763               default:
38764                 fatal("op idx %i out of bounds\n", opIdx);
38765                 return -1;
38766             }
38767         } // getOperandSize
38768
38769         bool
38770         isSrcOperand(int opIdx) override
38771         {
38772             switch (opIdx) {
38773               case 0: //src_0
38774                 return true;
38775               case 1: //src_1
38776                 return true;
38777               case 2: //sdst
38778                 return false;
38779               default:
38780                 fatal("op idx %i out of bounds\n", opIdx);
38781                 return false;
38782             }
38783         } // isSrcOperand
38784
38785         bool
38786         isDstOperand(int opIdx) override
38787         {
38788             switch (opIdx) {
38789               case 0: //src_0
38790                 return false;
38791               case 1: //src_1
38792                 return false;
38793               case 2: //sdst
38794                 return true;
38795               default:
38796                 fatal("op idx %i out of bounds\n", opIdx);
38797                 return false;
38798             }
38799         } // isDstOperand
38800
38801         void execute(GPUDynInstPtr) override;
38802     }; // Inst_VOP3__V_CMPX_NLE_F64
38803
38804     class Inst_VOP3__V_CMPX_NEQ_F64 : public Inst_VOP3
38805     {
38806       public:
38807         Inst_VOP3__V_CMPX_NEQ_F64(InFmt_VOP3*);
38808         ~Inst_VOP3__V_CMPX_NEQ_F64();
38809
38810         int
38811         getNumOperands() override
38812         {
38813             return numDstRegOperands() + numSrcRegOperands();
38814         } // getNumOperands
38815
38816         int numDstRegOperands() override { return 1; }
38817         int numSrcRegOperands() override { return 2; }
38818
38819         int
38820         getOperandSize(int opIdx) override
38821         {
38822             switch (opIdx) {
38823               case 0: //src_0
38824                 return 8;
38825               case 1: //src_1
38826                 return 8;
38827               case 2: //sdst
38828                 return 8;
38829               default:
38830                 fatal("op idx %i out of bounds\n", opIdx);
38831                 return -1;
38832             }
38833         } // getOperandSize
38834
38835         bool
38836         isSrcOperand(int opIdx) override
38837         {
38838             switch (opIdx) {
38839               case 0: //src_0
38840                 return true;
38841               case 1: //src_1
38842                 return true;
38843               case 2: //sdst
38844                 return false;
38845               default:
38846                 fatal("op idx %i out of bounds\n", opIdx);
38847                 return false;
38848             }
38849         } // isSrcOperand
38850
38851         bool
38852         isDstOperand(int opIdx) override
38853         {
38854             switch (opIdx) {
38855               case 0: //src_0
38856                 return false;
38857               case 1: //src_1
38858                 return false;
38859               case 2: //sdst
38860                 return true;
38861               default:
38862                 fatal("op idx %i out of bounds\n", opIdx);
38863                 return false;
38864             }
38865         } // isDstOperand
38866
38867         void execute(GPUDynInstPtr) override;
38868     }; // Inst_VOP3__V_CMPX_NEQ_F64
38869
38870     class Inst_VOP3__V_CMPX_NLT_F64 : public Inst_VOP3
38871     {
38872       public:
38873         Inst_VOP3__V_CMPX_NLT_F64(InFmt_VOP3*);
38874         ~Inst_VOP3__V_CMPX_NLT_F64();
38875
38876         int
38877         getNumOperands() override
38878         {
38879             return numDstRegOperands() + numSrcRegOperands();
38880         } // getNumOperands
38881
38882         int numDstRegOperands() override { return 1; }
38883         int numSrcRegOperands() override { return 2; }
38884
38885         int
38886         getOperandSize(int opIdx) override
38887         {
38888             switch (opIdx) {
38889               case 0: //src_0
38890                 return 8;
38891               case 1: //src_1
38892                 return 8;
38893               case 2: //sdst
38894                 return 8;
38895               default:
38896                 fatal("op idx %i out of bounds\n", opIdx);
38897                 return -1;
38898             }
38899         } // getOperandSize
38900
38901         bool
38902         isSrcOperand(int opIdx) override
38903         {
38904             switch (opIdx) {
38905               case 0: //src_0
38906                 return true;
38907               case 1: //src_1
38908                 return true;
38909               case 2: //sdst
38910                 return false;
38911               default:
38912                 fatal("op idx %i out of bounds\n", opIdx);
38913                 return false;
38914             }
38915         } // isSrcOperand
38916
38917         bool
38918         isDstOperand(int opIdx) override
38919         {
38920             switch (opIdx) {
38921               case 0: //src_0
38922                 return false;
38923               case 1: //src_1
38924                 return false;
38925               case 2: //sdst
38926                 return true;
38927               default:
38928                 fatal("op idx %i out of bounds\n", opIdx);
38929                 return false;
38930             }
38931         } // isDstOperand
38932
38933         void execute(GPUDynInstPtr) override;
38934     }; // Inst_VOP3__V_CMPX_NLT_F64
38935
38936     class Inst_VOP3__V_CMPX_TRU_F64 : public Inst_VOP3
38937     {
38938       public:
38939         Inst_VOP3__V_CMPX_TRU_F64(InFmt_VOP3*);
38940         ~Inst_VOP3__V_CMPX_TRU_F64();
38941
38942         int
38943         getNumOperands() override
38944         {
38945             return numDstRegOperands() + numSrcRegOperands();
38946         } // getNumOperands
38947
38948         int numDstRegOperands() override { return 1; }
38949         int numSrcRegOperands() override { return 2; }
38950
38951         int
38952         getOperandSize(int opIdx) override
38953         {
38954             switch (opIdx) {
38955               case 0: //src_0
38956                 return 8;
38957               case 1: //src_1
38958                 return 8;
38959               case 2: //sdst
38960                 return 8;
38961               default:
38962                 fatal("op idx %i out of bounds\n", opIdx);
38963                 return -1;
38964             }
38965         } // getOperandSize
38966
38967         bool
38968         isSrcOperand(int opIdx) override
38969         {
38970             switch (opIdx) {
38971               case 0: //src_0
38972                 return true;
38973               case 1: //src_1
38974                 return true;
38975               case 2: //sdst
38976                 return false;
38977               default:
38978                 fatal("op idx %i out of bounds\n", opIdx);
38979                 return false;
38980             }
38981         } // isSrcOperand
38982
38983         bool
38984         isDstOperand(int opIdx) override
38985         {
38986             switch (opIdx) {
38987               case 0: //src_0
38988                 return false;
38989               case 1: //src_1
38990                 return false;
38991               case 2: //sdst
38992                 return true;
38993               default:
38994                 fatal("op idx %i out of bounds\n", opIdx);
38995                 return false;
38996             }
38997         } // isDstOperand
38998
38999         void execute(GPUDynInstPtr) override;
39000     }; // Inst_VOP3__V_CMPX_TRU_F64
39001
39002     class Inst_VOP3__V_CMP_F_I16 : public Inst_VOP3
39003     {
39004       public:
39005         Inst_VOP3__V_CMP_F_I16(InFmt_VOP3*);
39006         ~Inst_VOP3__V_CMP_F_I16();
39007
39008         int
39009         getNumOperands() override
39010         {
39011             return numDstRegOperands() + numSrcRegOperands();
39012         } // getNumOperands
39013
39014         int numDstRegOperands() override { return 1; }
39015         int numSrcRegOperands() override { return 2; }
39016
39017         int
39018         getOperandSize(int opIdx) override
39019         {
39020             switch (opIdx) {
39021               case 0: //src_0
39022                 return 2;
39023               case 1: //src_1
39024                 return 2;
39025               case 2: //sdst
39026                 return 8;
39027               default:
39028                 fatal("op idx %i out of bounds\n", opIdx);
39029                 return -1;
39030             }
39031         } // getOperandSize
39032
39033         bool
39034         isSrcOperand(int opIdx) override
39035         {
39036             switch (opIdx) {
39037               case 0: //src_0
39038                 return true;
39039               case 1: //src_1
39040                 return true;
39041               case 2: //sdst
39042                 return false;
39043               default:
39044                 fatal("op idx %i out of bounds\n", opIdx);
39045                 return false;
39046             }
39047         } // isSrcOperand
39048
39049         bool
39050         isDstOperand(int opIdx) override
39051         {
39052             switch (opIdx) {
39053               case 0: //src_0
39054                 return false;
39055               case 1: //src_1
39056                 return false;
39057               case 2: //sdst
39058                 return true;
39059               default:
39060                 fatal("op idx %i out of bounds\n", opIdx);
39061                 return false;
39062             }
39063         } // isDstOperand
39064
39065         void execute(GPUDynInstPtr) override;
39066     }; // Inst_VOP3__V_CMP_F_I16
39067
39068     class Inst_VOP3__V_CMP_LT_I16 : public Inst_VOP3
39069     {
39070       public:
39071         Inst_VOP3__V_CMP_LT_I16(InFmt_VOP3*);
39072         ~Inst_VOP3__V_CMP_LT_I16();
39073
39074         int
39075         getNumOperands() override
39076         {
39077             return numDstRegOperands() + numSrcRegOperands();
39078         } // getNumOperands
39079
39080         int numDstRegOperands() override { return 1; }
39081         int numSrcRegOperands() override { return 2; }
39082
39083         int
39084         getOperandSize(int opIdx) override
39085         {
39086             switch (opIdx) {
39087               case 0: //src_0
39088                 return 2;
39089               case 1: //src_1
39090                 return 2;
39091               case 2: //sdst
39092                 return 8;
39093               default:
39094                 fatal("op idx %i out of bounds\n", opIdx);
39095                 return -1;
39096             }
39097         } // getOperandSize
39098
39099         bool
39100         isSrcOperand(int opIdx) override
39101         {
39102             switch (opIdx) {
39103               case 0: //src_0
39104                 return true;
39105               case 1: //src_1
39106                 return true;
39107               case 2: //sdst
39108                 return false;
39109               default:
39110                 fatal("op idx %i out of bounds\n", opIdx);
39111                 return false;
39112             }
39113         } // isSrcOperand
39114
39115         bool
39116         isDstOperand(int opIdx) override
39117         {
39118             switch (opIdx) {
39119               case 0: //src_0
39120                 return false;
39121               case 1: //src_1
39122                 return false;
39123               case 2: //sdst
39124                 return true;
39125               default:
39126                 fatal("op idx %i out of bounds\n", opIdx);
39127                 return false;
39128             }
39129         } // isDstOperand
39130
39131         void execute(GPUDynInstPtr) override;
39132     }; // Inst_VOP3__V_CMP_LT_I16
39133
39134     class Inst_VOP3__V_CMP_EQ_I16 : public Inst_VOP3
39135     {
39136       public:
39137         Inst_VOP3__V_CMP_EQ_I16(InFmt_VOP3*);
39138         ~Inst_VOP3__V_CMP_EQ_I16();
39139
39140         int
39141         getNumOperands() override
39142         {
39143             return numDstRegOperands() + numSrcRegOperands();
39144         } // getNumOperands
39145
39146         int numDstRegOperands() override { return 1; }
39147         int numSrcRegOperands() override { return 2; }
39148
39149         int
39150         getOperandSize(int opIdx) override
39151         {
39152             switch (opIdx) {
39153               case 0: //src_0
39154                 return 2;
39155               case 1: //src_1
39156                 return 2;
39157               case 2: //sdst
39158                 return 8;
39159               default:
39160                 fatal("op idx %i out of bounds\n", opIdx);
39161                 return -1;
39162             }
39163         } // getOperandSize
39164
39165         bool
39166         isSrcOperand(int opIdx) override
39167         {
39168             switch (opIdx) {
39169               case 0: //src_0
39170                 return true;
39171               case 1: //src_1
39172                 return true;
39173               case 2: //sdst
39174                 return false;
39175               default:
39176                 fatal("op idx %i out of bounds\n", opIdx);
39177                 return false;
39178             }
39179         } // isSrcOperand
39180
39181         bool
39182         isDstOperand(int opIdx) override
39183         {
39184             switch (opIdx) {
39185               case 0: //src_0
39186                 return false;
39187               case 1: //src_1
39188                 return false;
39189               case 2: //sdst
39190                 return true;
39191               default:
39192                 fatal("op idx %i out of bounds\n", opIdx);
39193                 return false;
39194             }
39195         } // isDstOperand
39196
39197         void execute(GPUDynInstPtr) override;
39198     }; // Inst_VOP3__V_CMP_EQ_I16
39199
39200     class Inst_VOP3__V_CMP_LE_I16 : public Inst_VOP3
39201     {
39202       public:
39203         Inst_VOP3__V_CMP_LE_I16(InFmt_VOP3*);
39204         ~Inst_VOP3__V_CMP_LE_I16();
39205
39206         int
39207         getNumOperands() override
39208         {
39209             return numDstRegOperands() + numSrcRegOperands();
39210         } // getNumOperands
39211
39212         int numDstRegOperands() override { return 1; }
39213         int numSrcRegOperands() override { return 2; }
39214
39215         int
39216         getOperandSize(int opIdx) override
39217         {
39218             switch (opIdx) {
39219               case 0: //src_0
39220                 return 2;
39221               case 1: //src_1
39222                 return 2;
39223               case 2: //sdst
39224                 return 8;
39225               default:
39226                 fatal("op idx %i out of bounds\n", opIdx);
39227                 return -1;
39228             }
39229         } // getOperandSize
39230
39231         bool
39232         isSrcOperand(int opIdx) override
39233         {
39234             switch (opIdx) {
39235               case 0: //src_0
39236                 return true;
39237               case 1: //src_1
39238                 return true;
39239               case 2: //sdst
39240                 return false;
39241               default:
39242                 fatal("op idx %i out of bounds\n", opIdx);
39243                 return false;
39244             }
39245         } // isSrcOperand
39246
39247         bool
39248         isDstOperand(int opIdx) override
39249         {
39250             switch (opIdx) {
39251               case 0: //src_0
39252                 return false;
39253               case 1: //src_1
39254                 return false;
39255               case 2: //sdst
39256                 return true;
39257               default:
39258                 fatal("op idx %i out of bounds\n", opIdx);
39259                 return false;
39260             }
39261         } // isDstOperand
39262
39263         void execute(GPUDynInstPtr) override;
39264     }; // Inst_VOP3__V_CMP_LE_I16
39265
39266     class Inst_VOP3__V_CMP_GT_I16 : public Inst_VOP3
39267     {
39268       public:
39269         Inst_VOP3__V_CMP_GT_I16(InFmt_VOP3*);
39270         ~Inst_VOP3__V_CMP_GT_I16();
39271
39272         int
39273         getNumOperands() override
39274         {
39275             return numDstRegOperands() + numSrcRegOperands();
39276         } // getNumOperands
39277
39278         int numDstRegOperands() override { return 1; }
39279         int numSrcRegOperands() override { return 2; }
39280
39281         int
39282         getOperandSize(int opIdx) override
39283         {
39284             switch (opIdx) {
39285               case 0: //src_0
39286                 return 2;
39287               case 1: //src_1
39288                 return 2;
39289               case 2: //sdst
39290                 return 8;
39291               default:
39292                 fatal("op idx %i out of bounds\n", opIdx);
39293                 return -1;
39294             }
39295         } // getOperandSize
39296
39297         bool
39298         isSrcOperand(int opIdx) override
39299         {
39300             switch (opIdx) {
39301               case 0: //src_0
39302                 return true;
39303               case 1: //src_1
39304                 return true;
39305               case 2: //sdst
39306                 return false;
39307               default:
39308                 fatal("op idx %i out of bounds\n", opIdx);
39309                 return false;
39310             }
39311         } // isSrcOperand
39312
39313         bool
39314         isDstOperand(int opIdx) override
39315         {
39316             switch (opIdx) {
39317               case 0: //src_0
39318                 return false;
39319               case 1: //src_1
39320                 return false;
39321               case 2: //sdst
39322                 return true;
39323               default:
39324                 fatal("op idx %i out of bounds\n", opIdx);
39325                 return false;
39326             }
39327         } // isDstOperand
39328
39329         void execute(GPUDynInstPtr) override;
39330     }; // Inst_VOP3__V_CMP_GT_I16
39331
39332     class Inst_VOP3__V_CMP_NE_I16 : public Inst_VOP3
39333     {
39334       public:
39335         Inst_VOP3__V_CMP_NE_I16(InFmt_VOP3*);
39336         ~Inst_VOP3__V_CMP_NE_I16();
39337
39338         int
39339         getNumOperands() override
39340         {
39341             return numDstRegOperands() + numSrcRegOperands();
39342         } // getNumOperands
39343
39344         int numDstRegOperands() override { return 1; }
39345         int numSrcRegOperands() override { return 2; }
39346
39347         int
39348         getOperandSize(int opIdx) override
39349         {
39350             switch (opIdx) {
39351               case 0: //src_0
39352                 return 2;
39353               case 1: //src_1
39354                 return 2;
39355               case 2: //sdst
39356                 return 8;
39357               default:
39358                 fatal("op idx %i out of bounds\n", opIdx);
39359                 return -1;
39360             }
39361         } // getOperandSize
39362
39363         bool
39364         isSrcOperand(int opIdx) override
39365         {
39366             switch (opIdx) {
39367               case 0: //src_0
39368                 return true;
39369               case 1: //src_1
39370                 return true;
39371               case 2: //sdst
39372                 return false;
39373               default:
39374                 fatal("op idx %i out of bounds\n", opIdx);
39375                 return false;
39376             }
39377         } // isSrcOperand
39378
39379         bool
39380         isDstOperand(int opIdx) override
39381         {
39382             switch (opIdx) {
39383               case 0: //src_0
39384                 return false;
39385               case 1: //src_1
39386                 return false;
39387               case 2: //sdst
39388                 return true;
39389               default:
39390                 fatal("op idx %i out of bounds\n", opIdx);
39391                 return false;
39392             }
39393         } // isDstOperand
39394
39395         void execute(GPUDynInstPtr) override;
39396     }; // Inst_VOP3__V_CMP_NE_I16
39397
39398     class Inst_VOP3__V_CMP_GE_I16 : public Inst_VOP3
39399     {
39400       public:
39401         Inst_VOP3__V_CMP_GE_I16(InFmt_VOP3*);
39402         ~Inst_VOP3__V_CMP_GE_I16();
39403
39404         int
39405         getNumOperands() override
39406         {
39407             return numDstRegOperands() + numSrcRegOperands();
39408         } // getNumOperands
39409
39410         int numDstRegOperands() override { return 1; }
39411         int numSrcRegOperands() override { return 2; }
39412
39413         int
39414         getOperandSize(int opIdx) override
39415         {
39416             switch (opIdx) {
39417               case 0: //src_0
39418                 return 2;
39419               case 1: //src_1
39420                 return 2;
39421               case 2: //sdst
39422                 return 8;
39423               default:
39424                 fatal("op idx %i out of bounds\n", opIdx);
39425                 return -1;
39426             }
39427         } // getOperandSize
39428
39429         bool
39430         isSrcOperand(int opIdx) override
39431         {
39432             switch (opIdx) {
39433               case 0: //src_0
39434                 return true;
39435               case 1: //src_1
39436                 return true;
39437               case 2: //sdst
39438                 return false;
39439               default:
39440                 fatal("op idx %i out of bounds\n", opIdx);
39441                 return false;
39442             }
39443         } // isSrcOperand
39444
39445         bool
39446         isDstOperand(int opIdx) override
39447         {
39448             switch (opIdx) {
39449               case 0: //src_0
39450                 return false;
39451               case 1: //src_1
39452                 return false;
39453               case 2: //sdst
39454                 return true;
39455               default:
39456                 fatal("op idx %i out of bounds\n", opIdx);
39457                 return false;
39458             }
39459         } // isDstOperand
39460
39461         void execute(GPUDynInstPtr) override;
39462     }; // Inst_VOP3__V_CMP_GE_I16
39463
39464     class Inst_VOP3__V_CMP_T_I16 : public Inst_VOP3
39465     {
39466       public:
39467         Inst_VOP3__V_CMP_T_I16(InFmt_VOP3*);
39468         ~Inst_VOP3__V_CMP_T_I16();
39469
39470         int
39471         getNumOperands() override
39472         {
39473             return numDstRegOperands() + numSrcRegOperands();
39474         } // getNumOperands
39475
39476         int numDstRegOperands() override { return 1; }
39477         int numSrcRegOperands() override { return 2; }
39478
39479         int
39480         getOperandSize(int opIdx) override
39481         {
39482             switch (opIdx) {
39483               case 0: //src_0
39484                 return 2;
39485               case 1: //src_1
39486                 return 2;
39487               case 2: //sdst
39488                 return 8;
39489               default:
39490                 fatal("op idx %i out of bounds\n", opIdx);
39491                 return -1;
39492             }
39493         } // getOperandSize
39494
39495         bool
39496         isSrcOperand(int opIdx) override
39497         {
39498             switch (opIdx) {
39499               case 0: //src_0
39500                 return true;
39501               case 1: //src_1
39502                 return true;
39503               case 2: //sdst
39504                 return false;
39505               default:
39506                 fatal("op idx %i out of bounds\n", opIdx);
39507                 return false;
39508             }
39509         } // isSrcOperand
39510
39511         bool
39512         isDstOperand(int opIdx) override
39513         {
39514             switch (opIdx) {
39515               case 0: //src_0
39516                 return false;
39517               case 1: //src_1
39518                 return false;
39519               case 2: //sdst
39520                 return true;
39521               default:
39522                 fatal("op idx %i out of bounds\n", opIdx);
39523                 return false;
39524             }
39525         } // isDstOperand
39526
39527         void execute(GPUDynInstPtr) override;
39528     }; // Inst_VOP3__V_CMP_T_I16
39529
39530     class Inst_VOP3__V_CMP_F_U16 : public Inst_VOP3
39531     {
39532       public:
39533         Inst_VOP3__V_CMP_F_U16(InFmt_VOP3*);
39534         ~Inst_VOP3__V_CMP_F_U16();
39535
39536         int
39537         getNumOperands() override
39538         {
39539             return numDstRegOperands() + numSrcRegOperands();
39540         } // getNumOperands
39541
39542         int numDstRegOperands() override { return 1; }
39543         int numSrcRegOperands() override { return 2; }
39544
39545         int
39546         getOperandSize(int opIdx) override
39547         {
39548             switch (opIdx) {
39549               case 0: //src_0
39550                 return 2;
39551               case 1: //src_1
39552                 return 2;
39553               case 2: //sdst
39554                 return 8;
39555               default:
39556                 fatal("op idx %i out of bounds\n", opIdx);
39557                 return -1;
39558             }
39559         } // getOperandSize
39560
39561         bool
39562         isSrcOperand(int opIdx) override
39563         {
39564             switch (opIdx) {
39565               case 0: //src_0
39566                 return true;
39567               case 1: //src_1
39568                 return true;
39569               case 2: //sdst
39570                 return false;
39571               default:
39572                 fatal("op idx %i out of bounds\n", opIdx);
39573                 return false;
39574             }
39575         } // isSrcOperand
39576
39577         bool
39578         isDstOperand(int opIdx) override
39579         {
39580             switch (opIdx) {
39581               case 0: //src_0
39582                 return false;
39583               case 1: //src_1
39584                 return false;
39585               case 2: //sdst
39586                 return true;
39587               default:
39588                 fatal("op idx %i out of bounds\n", opIdx);
39589                 return false;
39590             }
39591         } // isDstOperand
39592
39593         void execute(GPUDynInstPtr) override;
39594     }; // Inst_VOP3__V_CMP_F_U16
39595
39596     class Inst_VOP3__V_CMP_LT_U16 : public Inst_VOP3
39597     {
39598       public:
39599         Inst_VOP3__V_CMP_LT_U16(InFmt_VOP3*);
39600         ~Inst_VOP3__V_CMP_LT_U16();
39601
39602         int
39603         getNumOperands() override
39604         {
39605             return numDstRegOperands() + numSrcRegOperands();
39606         } // getNumOperands
39607
39608         int numDstRegOperands() override { return 1; }
39609         int numSrcRegOperands() override { return 2; }
39610
39611         int
39612         getOperandSize(int opIdx) override
39613         {
39614             switch (opIdx) {
39615               case 0: //src_0
39616                 return 2;
39617               case 1: //src_1
39618                 return 2;
39619               case 2: //sdst
39620                 return 8;
39621               default:
39622                 fatal("op idx %i out of bounds\n", opIdx);
39623                 return -1;
39624             }
39625         } // getOperandSize
39626
39627         bool
39628         isSrcOperand(int opIdx) override
39629         {
39630             switch (opIdx) {
39631               case 0: //src_0
39632                 return true;
39633               case 1: //src_1
39634                 return true;
39635               case 2: //sdst
39636                 return false;
39637               default:
39638                 fatal("op idx %i out of bounds\n", opIdx);
39639                 return false;
39640             }
39641         } // isSrcOperand
39642
39643         bool
39644         isDstOperand(int opIdx) override
39645         {
39646             switch (opIdx) {
39647               case 0: //src_0
39648                 return false;
39649               case 1: //src_1
39650                 return false;
39651               case 2: //sdst
39652                 return true;
39653               default:
39654                 fatal("op idx %i out of bounds\n", opIdx);
39655                 return false;
39656             }
39657         } // isDstOperand
39658
39659         void execute(GPUDynInstPtr) override;
39660     }; // Inst_VOP3__V_CMP_LT_U16
39661
39662     class Inst_VOP3__V_CMP_EQ_U16 : public Inst_VOP3
39663     {
39664       public:
39665         Inst_VOP3__V_CMP_EQ_U16(InFmt_VOP3*);
39666         ~Inst_VOP3__V_CMP_EQ_U16();
39667
39668         int
39669         getNumOperands() override
39670         {
39671             return numDstRegOperands() + numSrcRegOperands();
39672         } // getNumOperands
39673
39674         int numDstRegOperands() override { return 1; }
39675         int numSrcRegOperands() override { return 2; }
39676
39677         int
39678         getOperandSize(int opIdx) override
39679         {
39680             switch (opIdx) {
39681               case 0: //src_0
39682                 return 2;
39683               case 1: //src_1
39684                 return 2;
39685               case 2: //sdst
39686                 return 8;
39687               default:
39688                 fatal("op idx %i out of bounds\n", opIdx);
39689                 return -1;
39690             }
39691         } // getOperandSize
39692
39693         bool
39694         isSrcOperand(int opIdx) override
39695         {
39696             switch (opIdx) {
39697               case 0: //src_0
39698                 return true;
39699               case 1: //src_1
39700                 return true;
39701               case 2: //sdst
39702                 return false;
39703               default:
39704                 fatal("op idx %i out of bounds\n", opIdx);
39705                 return false;
39706             }
39707         } // isSrcOperand
39708
39709         bool
39710         isDstOperand(int opIdx) override
39711         {
39712             switch (opIdx) {
39713               case 0: //src_0
39714                 return false;
39715               case 1: //src_1
39716                 return false;
39717               case 2: //sdst
39718                 return true;
39719               default:
39720                 fatal("op idx %i out of bounds\n", opIdx);
39721                 return false;
39722             }
39723         } // isDstOperand
39724
39725         void execute(GPUDynInstPtr) override;
39726     }; // Inst_VOP3__V_CMP_EQ_U16
39727
39728     class Inst_VOP3__V_CMP_LE_U16 : public Inst_VOP3
39729     {
39730       public:
39731         Inst_VOP3__V_CMP_LE_U16(InFmt_VOP3*);
39732         ~Inst_VOP3__V_CMP_LE_U16();
39733
39734         int
39735         getNumOperands() override
39736         {
39737             return numDstRegOperands() + numSrcRegOperands();
39738         } // getNumOperands
39739
39740         int numDstRegOperands() override { return 1; }
39741         int numSrcRegOperands() override { return 2; }
39742
39743         int
39744         getOperandSize(int opIdx) override
39745         {
39746             switch (opIdx) {
39747               case 0: //src_0
39748                 return 2;
39749               case 1: //src_1
39750                 return 2;
39751               case 2: //sdst
39752                 return 8;
39753               default:
39754                 fatal("op idx %i out of bounds\n", opIdx);
39755                 return -1;
39756             }
39757         } // getOperandSize
39758
39759         bool
39760         isSrcOperand(int opIdx) override
39761         {
39762             switch (opIdx) {
39763               case 0: //src_0
39764                 return true;
39765               case 1: //src_1
39766                 return true;
39767               case 2: //sdst
39768                 return false;
39769               default:
39770                 fatal("op idx %i out of bounds\n", opIdx);
39771                 return false;
39772             }
39773         } // isSrcOperand
39774
39775         bool
39776         isDstOperand(int opIdx) override
39777         {
39778             switch (opIdx) {
39779               case 0: //src_0
39780                 return false;
39781               case 1: //src_1
39782                 return false;
39783               case 2: //sdst
39784                 return true;
39785               default:
39786                 fatal("op idx %i out of bounds\n", opIdx);
39787                 return false;
39788             }
39789         } // isDstOperand
39790
39791         void execute(GPUDynInstPtr) override;
39792     }; // Inst_VOP3__V_CMP_LE_U16
39793
39794     class Inst_VOP3__V_CMP_GT_U16 : public Inst_VOP3
39795     {
39796       public:
39797         Inst_VOP3__V_CMP_GT_U16(InFmt_VOP3*);
39798         ~Inst_VOP3__V_CMP_GT_U16();
39799
39800         int
39801         getNumOperands() override
39802         {
39803             return numDstRegOperands() + numSrcRegOperands();
39804         } // getNumOperands
39805
39806         int numDstRegOperands() override { return 1; }
39807         int numSrcRegOperands() override { return 2; }
39808
39809         int
39810         getOperandSize(int opIdx) override
39811         {
39812             switch (opIdx) {
39813               case 0: //src_0
39814                 return 2;
39815               case 1: //src_1
39816                 return 2;
39817               case 2: //sdst
39818                 return 8;
39819               default:
39820                 fatal("op idx %i out of bounds\n", opIdx);
39821                 return -1;
39822             }
39823         } // getOperandSize
39824
39825         bool
39826         isSrcOperand(int opIdx) override
39827         {
39828             switch (opIdx) {
39829               case 0: //src_0
39830                 return true;
39831               case 1: //src_1
39832                 return true;
39833               case 2: //sdst
39834                 return false;
39835               default:
39836                 fatal("op idx %i out of bounds\n", opIdx);
39837                 return false;
39838             }
39839         } // isSrcOperand
39840
39841         bool
39842         isDstOperand(int opIdx) override
39843         {
39844             switch (opIdx) {
39845               case 0: //src_0
39846                 return false;
39847               case 1: //src_1
39848                 return false;
39849               case 2: //sdst
39850                 return true;
39851               default:
39852                 fatal("op idx %i out of bounds\n", opIdx);
39853                 return false;
39854             }
39855         } // isDstOperand
39856
39857         void execute(GPUDynInstPtr) override;
39858     }; // Inst_VOP3__V_CMP_GT_U16
39859
39860     class Inst_VOP3__V_CMP_NE_U16 : public Inst_VOP3
39861     {
39862       public:
39863         Inst_VOP3__V_CMP_NE_U16(InFmt_VOP3*);
39864         ~Inst_VOP3__V_CMP_NE_U16();
39865
39866         int
39867         getNumOperands() override
39868         {
39869             return numDstRegOperands() + numSrcRegOperands();
39870         } // getNumOperands
39871
39872         int numDstRegOperands() override { return 1; }
39873         int numSrcRegOperands() override { return 2; }
39874
39875         int
39876         getOperandSize(int opIdx) override
39877         {
39878             switch (opIdx) {
39879               case 0: //src_0
39880                 return 2;
39881               case 1: //src_1
39882                 return 2;
39883               case 2: //sdst
39884                 return 8;
39885               default:
39886                 fatal("op idx %i out of bounds\n", opIdx);
39887                 return -1;
39888             }
39889         } // getOperandSize
39890
39891         bool
39892         isSrcOperand(int opIdx) override
39893         {
39894             switch (opIdx) {
39895               case 0: //src_0
39896                 return true;
39897               case 1: //src_1
39898                 return true;
39899               case 2: //sdst
39900                 return false;
39901               default:
39902                 fatal("op idx %i out of bounds\n", opIdx);
39903                 return false;
39904             }
39905         } // isSrcOperand
39906
39907         bool
39908         isDstOperand(int opIdx) override
39909         {
39910             switch (opIdx) {
39911               case 0: //src_0
39912                 return false;
39913               case 1: //src_1
39914                 return false;
39915               case 2: //sdst
39916                 return true;
39917               default:
39918                 fatal("op idx %i out of bounds\n", opIdx);
39919                 return false;
39920             }
39921         } // isDstOperand
39922
39923         void execute(GPUDynInstPtr) override;
39924     }; // Inst_VOP3__V_CMP_NE_U16
39925
39926     class Inst_VOP3__V_CMP_GE_U16 : public Inst_VOP3
39927     {
39928       public:
39929         Inst_VOP3__V_CMP_GE_U16(InFmt_VOP3*);
39930         ~Inst_VOP3__V_CMP_GE_U16();
39931
39932         int
39933         getNumOperands() override
39934         {
39935             return numDstRegOperands() + numSrcRegOperands();
39936         } // getNumOperands
39937
39938         int numDstRegOperands() override { return 1; }
39939         int numSrcRegOperands() override { return 2; }
39940
39941         int
39942         getOperandSize(int opIdx) override
39943         {
39944             switch (opIdx) {
39945               case 0: //src_0
39946                 return 2;
39947               case 1: //src_1
39948                 return 2;
39949               case 2: //sdst
39950                 return 8;
39951               default:
39952                 fatal("op idx %i out of bounds\n", opIdx);
39953                 return -1;
39954             }
39955         } // getOperandSize
39956
39957         bool
39958         isSrcOperand(int opIdx) override
39959         {
39960             switch (opIdx) {
39961               case 0: //src_0
39962                 return true;
39963               case 1: //src_1
39964                 return true;
39965               case 2: //sdst
39966                 return false;
39967               default:
39968                 fatal("op idx %i out of bounds\n", opIdx);
39969                 return false;
39970             }
39971         } // isSrcOperand
39972
39973         bool
39974         isDstOperand(int opIdx) override
39975         {
39976             switch (opIdx) {
39977               case 0: //src_0
39978                 return false;
39979               case 1: //src_1
39980                 return false;
39981               case 2: //sdst
39982                 return true;
39983               default:
39984                 fatal("op idx %i out of bounds\n", opIdx);
39985                 return false;
39986             }
39987         } // isDstOperand
39988
39989         void execute(GPUDynInstPtr) override;
39990     }; // Inst_VOP3__V_CMP_GE_U16
39991
39992     class Inst_VOP3__V_CMP_T_U16 : public Inst_VOP3
39993     {
39994       public:
39995         Inst_VOP3__V_CMP_T_U16(InFmt_VOP3*);
39996         ~Inst_VOP3__V_CMP_T_U16();
39997
39998         int
39999         getNumOperands() override
40000         {
40001             return numDstRegOperands() + numSrcRegOperands();
40002         } // getNumOperands
40003
40004         int numDstRegOperands() override { return 1; }
40005         int numSrcRegOperands() override { return 2; }
40006
40007         int
40008         getOperandSize(int opIdx) override
40009         {
40010             switch (opIdx) {
40011               case 0: //src_0
40012                 return 2;
40013               case 1: //src_1
40014                 return 2;
40015               case 2: //sdst
40016                 return 8;
40017               default:
40018                 fatal("op idx %i out of bounds\n", opIdx);
40019                 return -1;
40020             }
40021         } // getOperandSize
40022
40023         bool
40024         isSrcOperand(int opIdx) override
40025         {
40026             switch (opIdx) {
40027               case 0: //src_0
40028                 return true;
40029               case 1: //src_1
40030                 return true;
40031               case 2: //sdst
40032                 return false;
40033               default:
40034                 fatal("op idx %i out of bounds\n", opIdx);
40035                 return false;
40036             }
40037         } // isSrcOperand
40038
40039         bool
40040         isDstOperand(int opIdx) override
40041         {
40042             switch (opIdx) {
40043               case 0: //src_0
40044                 return false;
40045               case 1: //src_1
40046                 return false;
40047               case 2: //sdst
40048                 return true;
40049               default:
40050                 fatal("op idx %i out of bounds\n", opIdx);
40051                 return false;
40052             }
40053         } // isDstOperand
40054
40055         void execute(GPUDynInstPtr) override;
40056     }; // Inst_VOP3__V_CMP_T_U16
40057
40058     class Inst_VOP3__V_CMPX_F_I16 : public Inst_VOP3
40059     {
40060       public:
40061         Inst_VOP3__V_CMPX_F_I16(InFmt_VOP3*);
40062         ~Inst_VOP3__V_CMPX_F_I16();
40063
40064         int
40065         getNumOperands() override
40066         {
40067             return numDstRegOperands() + numSrcRegOperands();
40068         } // getNumOperands
40069
40070         int numDstRegOperands() override { return 1; }
40071         int numSrcRegOperands() override { return 2; }
40072
40073         int
40074         getOperandSize(int opIdx) override
40075         {
40076             switch (opIdx) {
40077               case 0: //src_0
40078                 return 2;
40079               case 1: //src_1
40080                 return 2;
40081               case 2: //sdst
40082                 return 8;
40083               default:
40084                 fatal("op idx %i out of bounds\n", opIdx);
40085                 return -1;
40086             }
40087         } // getOperandSize
40088
40089         bool
40090         isSrcOperand(int opIdx) override
40091         {
40092             switch (opIdx) {
40093               case 0: //src_0
40094                 return true;
40095               case 1: //src_1
40096                 return true;
40097               case 2: //sdst
40098                 return false;
40099               default:
40100                 fatal("op idx %i out of bounds\n", opIdx);
40101                 return false;
40102             }
40103         } // isSrcOperand
40104
40105         bool
40106         isDstOperand(int opIdx) override
40107         {
40108             switch (opIdx) {
40109               case 0: //src_0
40110                 return false;
40111               case 1: //src_1
40112                 return false;
40113               case 2: //sdst
40114                 return true;
40115               default:
40116                 fatal("op idx %i out of bounds\n", opIdx);
40117                 return false;
40118             }
40119         } // isDstOperand
40120
40121         void execute(GPUDynInstPtr) override;
40122     }; // Inst_VOP3__V_CMPX_F_I16
40123
40124     class Inst_VOP3__V_CMPX_LT_I16 : public Inst_VOP3
40125     {
40126       public:
40127         Inst_VOP3__V_CMPX_LT_I16(InFmt_VOP3*);
40128         ~Inst_VOP3__V_CMPX_LT_I16();
40129
40130         int
40131         getNumOperands() override
40132         {
40133             return numDstRegOperands() + numSrcRegOperands();
40134         } // getNumOperands
40135
40136         int numDstRegOperands() override { return 1; }
40137         int numSrcRegOperands() override { return 2; }
40138
40139         int
40140         getOperandSize(int opIdx) override
40141         {
40142             switch (opIdx) {
40143               case 0: //src_0
40144                 return 2;
40145               case 1: //src_1
40146                 return 2;
40147               case 2: //sdst
40148                 return 8;
40149               default:
40150                 fatal("op idx %i out of bounds\n", opIdx);
40151                 return -1;
40152             }
40153         } // getOperandSize
40154
40155         bool
40156         isSrcOperand(int opIdx) override
40157         {
40158             switch (opIdx) {
40159               case 0: //src_0
40160                 return true;
40161               case 1: //src_1
40162                 return true;
40163               case 2: //sdst
40164                 return false;
40165               default:
40166                 fatal("op idx %i out of bounds\n", opIdx);
40167                 return false;
40168             }
40169         } // isSrcOperand
40170
40171         bool
40172         isDstOperand(int opIdx) override
40173         {
40174             switch (opIdx) {
40175               case 0: //src_0
40176                 return false;
40177               case 1: //src_1
40178                 return false;
40179               case 2: //sdst
40180                 return true;
40181               default:
40182                 fatal("op idx %i out of bounds\n", opIdx);
40183                 return false;
40184             }
40185         } // isDstOperand
40186
40187         void execute(GPUDynInstPtr) override;
40188     }; // Inst_VOP3__V_CMPX_LT_I16
40189
40190     class Inst_VOP3__V_CMPX_EQ_I16 : public Inst_VOP3
40191     {
40192       public:
40193         Inst_VOP3__V_CMPX_EQ_I16(InFmt_VOP3*);
40194         ~Inst_VOP3__V_CMPX_EQ_I16();
40195
40196         int
40197         getNumOperands() override
40198         {
40199             return numDstRegOperands() + numSrcRegOperands();
40200         } // getNumOperands
40201
40202         int numDstRegOperands() override { return 1; }
40203         int numSrcRegOperands() override { return 2; }
40204
40205         int
40206         getOperandSize(int opIdx) override
40207         {
40208             switch (opIdx) {
40209               case 0: //src_0
40210                 return 2;
40211               case 1: //src_1
40212                 return 2;
40213               case 2: //sdst
40214                 return 8;
40215               default:
40216                 fatal("op idx %i out of bounds\n", opIdx);
40217                 return -1;
40218             }
40219         } // getOperandSize
40220
40221         bool
40222         isSrcOperand(int opIdx) override
40223         {
40224             switch (opIdx) {
40225               case 0: //src_0
40226                 return true;
40227               case 1: //src_1
40228                 return true;
40229               case 2: //sdst
40230                 return false;
40231               default:
40232                 fatal("op idx %i out of bounds\n", opIdx);
40233                 return false;
40234             }
40235         } // isSrcOperand
40236
40237         bool
40238         isDstOperand(int opIdx) override
40239         {
40240             switch (opIdx) {
40241               case 0: //src_0
40242                 return false;
40243               case 1: //src_1
40244                 return false;
40245               case 2: //sdst
40246                 return true;
40247               default:
40248                 fatal("op idx %i out of bounds\n", opIdx);
40249                 return false;
40250             }
40251         } // isDstOperand
40252
40253         void execute(GPUDynInstPtr) override;
40254     }; // Inst_VOP3__V_CMPX_EQ_I16
40255
40256     class Inst_VOP3__V_CMPX_LE_I16 : public Inst_VOP3
40257     {
40258       public:
40259         Inst_VOP3__V_CMPX_LE_I16(InFmt_VOP3*);
40260         ~Inst_VOP3__V_CMPX_LE_I16();
40261
40262         int
40263         getNumOperands() override
40264         {
40265             return numDstRegOperands() + numSrcRegOperands();
40266         } // getNumOperands
40267
40268         int numDstRegOperands() override { return 1; }
40269         int numSrcRegOperands() override { return 2; }
40270
40271         int
40272         getOperandSize(int opIdx) override
40273         {
40274             switch (opIdx) {
40275               case 0: //src_0
40276                 return 2;
40277               case 1: //src_1
40278                 return 2;
40279               case 2: //sdst
40280                 return 8;
40281               default:
40282                 fatal("op idx %i out of bounds\n", opIdx);
40283                 return -1;
40284             }
40285         } // getOperandSize
40286
40287         bool
40288         isSrcOperand(int opIdx) override
40289         {
40290             switch (opIdx) {
40291               case 0: //src_0
40292                 return true;
40293               case 1: //src_1
40294                 return true;
40295               case 2: //sdst
40296                 return false;
40297               default:
40298                 fatal("op idx %i out of bounds\n", opIdx);
40299                 return false;
40300             }
40301         } // isSrcOperand
40302
40303         bool
40304         isDstOperand(int opIdx) override
40305         {
40306             switch (opIdx) {
40307               case 0: //src_0
40308                 return false;
40309               case 1: //src_1
40310                 return false;
40311               case 2: //sdst
40312                 return true;
40313               default:
40314                 fatal("op idx %i out of bounds\n", opIdx);
40315                 return false;
40316             }
40317         } // isDstOperand
40318
40319         void execute(GPUDynInstPtr) override;
40320     }; // Inst_VOP3__V_CMPX_LE_I16
40321
40322     class Inst_VOP3__V_CMPX_GT_I16 : public Inst_VOP3
40323     {
40324       public:
40325         Inst_VOP3__V_CMPX_GT_I16(InFmt_VOP3*);
40326         ~Inst_VOP3__V_CMPX_GT_I16();
40327
40328         int
40329         getNumOperands() override
40330         {
40331             return numDstRegOperands() + numSrcRegOperands();
40332         } // getNumOperands
40333
40334         int numDstRegOperands() override { return 1; }
40335         int numSrcRegOperands() override { return 2; }
40336
40337         int
40338         getOperandSize(int opIdx) override
40339         {
40340             switch (opIdx) {
40341               case 0: //src_0
40342                 return 2;
40343               case 1: //src_1
40344                 return 2;
40345               case 2: //sdst
40346                 return 8;
40347               default:
40348                 fatal("op idx %i out of bounds\n", opIdx);
40349                 return -1;
40350             }
40351         } // getOperandSize
40352
40353         bool
40354         isSrcOperand(int opIdx) override
40355         {
40356             switch (opIdx) {
40357               case 0: //src_0
40358                 return true;
40359               case 1: //src_1
40360                 return true;
40361               case 2: //sdst
40362                 return false;
40363               default:
40364                 fatal("op idx %i out of bounds\n", opIdx);
40365                 return false;
40366             }
40367         } // isSrcOperand
40368
40369         bool
40370         isDstOperand(int opIdx) override
40371         {
40372             switch (opIdx) {
40373               case 0: //src_0
40374                 return false;
40375               case 1: //src_1
40376                 return false;
40377               case 2: //sdst
40378                 return true;
40379               default:
40380                 fatal("op idx %i out of bounds\n", opIdx);
40381                 return false;
40382             }
40383         } // isDstOperand
40384
40385         void execute(GPUDynInstPtr) override;
40386     }; // Inst_VOP3__V_CMPX_GT_I16
40387
40388     class Inst_VOP3__V_CMPX_NE_I16 : public Inst_VOP3
40389     {
40390       public:
40391         Inst_VOP3__V_CMPX_NE_I16(InFmt_VOP3*);
40392         ~Inst_VOP3__V_CMPX_NE_I16();
40393
40394         int
40395         getNumOperands() override
40396         {
40397             return numDstRegOperands() + numSrcRegOperands();
40398         } // getNumOperands
40399
40400         int numDstRegOperands() override { return 1; }
40401         int numSrcRegOperands() override { return 2; }
40402
40403         int
40404         getOperandSize(int opIdx) override
40405         {
40406             switch (opIdx) {
40407               case 0: //src_0
40408                 return 2;
40409               case 1: //src_1
40410                 return 2;
40411               case 2: //sdst
40412                 return 8;
40413               default:
40414                 fatal("op idx %i out of bounds\n", opIdx);
40415                 return -1;
40416             }
40417         } // getOperandSize
40418
40419         bool
40420         isSrcOperand(int opIdx) override
40421         {
40422             switch (opIdx) {
40423               case 0: //src_0
40424                 return true;
40425               case 1: //src_1
40426                 return true;
40427               case 2: //sdst
40428                 return false;
40429               default:
40430                 fatal("op idx %i out of bounds\n", opIdx);
40431                 return false;
40432             }
40433         } // isSrcOperand
40434
40435         bool
40436         isDstOperand(int opIdx) override
40437         {
40438             switch (opIdx) {
40439               case 0: //src_0
40440                 return false;
40441               case 1: //src_1
40442                 return false;
40443               case 2: //sdst
40444                 return true;
40445               default:
40446                 fatal("op idx %i out of bounds\n", opIdx);
40447                 return false;
40448             }
40449         } // isDstOperand
40450
40451         void execute(GPUDynInstPtr) override;
40452     }; // Inst_VOP3__V_CMPX_NE_I16
40453
40454     class Inst_VOP3__V_CMPX_GE_I16 : public Inst_VOP3
40455     {
40456       public:
40457         Inst_VOP3__V_CMPX_GE_I16(InFmt_VOP3*);
40458         ~Inst_VOP3__V_CMPX_GE_I16();
40459
40460         int
40461         getNumOperands() override
40462         {
40463             return numDstRegOperands() + numSrcRegOperands();
40464         } // getNumOperands
40465
40466         int numDstRegOperands() override { return 1; }
40467         int numSrcRegOperands() override { return 2; }
40468
40469         int
40470         getOperandSize(int opIdx) override
40471         {
40472             switch (opIdx) {
40473               case 0: //src_0
40474                 return 2;
40475               case 1: //src_1
40476                 return 2;
40477               case 2: //sdst
40478                 return 8;
40479               default:
40480                 fatal("op idx %i out of bounds\n", opIdx);
40481                 return -1;
40482             }
40483         } // getOperandSize
40484
40485         bool
40486         isSrcOperand(int opIdx) override
40487         {
40488             switch (opIdx) {
40489               case 0: //src_0
40490                 return true;
40491               case 1: //src_1
40492                 return true;
40493               case 2: //sdst
40494                 return false;
40495               default:
40496                 fatal("op idx %i out of bounds\n", opIdx);
40497                 return false;
40498             }
40499         } // isSrcOperand
40500
40501         bool
40502         isDstOperand(int opIdx) override
40503         {
40504             switch (opIdx) {
40505               case 0: //src_0
40506                 return false;
40507               case 1: //src_1
40508                 return false;
40509               case 2: //sdst
40510                 return true;
40511               default:
40512                 fatal("op idx %i out of bounds\n", opIdx);
40513                 return false;
40514             }
40515         } // isDstOperand
40516
40517         void execute(GPUDynInstPtr) override;
40518     }; // Inst_VOP3__V_CMPX_GE_I16
40519
40520     class Inst_VOP3__V_CMPX_T_I16 : public Inst_VOP3
40521     {
40522       public:
40523         Inst_VOP3__V_CMPX_T_I16(InFmt_VOP3*);
40524         ~Inst_VOP3__V_CMPX_T_I16();
40525
40526         int
40527         getNumOperands() override
40528         {
40529             return numDstRegOperands() + numSrcRegOperands();
40530         } // getNumOperands
40531
40532         int numDstRegOperands() override { return 1; }
40533         int numSrcRegOperands() override { return 2; }
40534
40535         int
40536         getOperandSize(int opIdx) override
40537         {
40538             switch (opIdx) {
40539               case 0: //src_0
40540                 return 2;
40541               case 1: //src_1
40542                 return 2;
40543               case 2: //sdst
40544                 return 8;
40545               default:
40546                 fatal("op idx %i out of bounds\n", opIdx);
40547                 return -1;
40548             }
40549         } // getOperandSize
40550
40551         bool
40552         isSrcOperand(int opIdx) override
40553         {
40554             switch (opIdx) {
40555               case 0: //src_0
40556                 return true;
40557               case 1: //src_1
40558                 return true;
40559               case 2: //sdst
40560                 return false;
40561               default:
40562                 fatal("op idx %i out of bounds\n", opIdx);
40563                 return false;
40564             }
40565         } // isSrcOperand
40566
40567         bool
40568         isDstOperand(int opIdx) override
40569         {
40570             switch (opIdx) {
40571               case 0: //src_0
40572                 return false;
40573               case 1: //src_1
40574                 return false;
40575               case 2: //sdst
40576                 return true;
40577               default:
40578                 fatal("op idx %i out of bounds\n", opIdx);
40579                 return false;
40580             }
40581         } // isDstOperand
40582
40583         void execute(GPUDynInstPtr) override;
40584     }; // Inst_VOP3__V_CMPX_T_I16
40585
40586     class Inst_VOP3__V_CMPX_F_U16 : public Inst_VOP3
40587     {
40588       public:
40589         Inst_VOP3__V_CMPX_F_U16(InFmt_VOP3*);
40590         ~Inst_VOP3__V_CMPX_F_U16();
40591
40592         int
40593         getNumOperands() override
40594         {
40595             return numDstRegOperands() + numSrcRegOperands();
40596         } // getNumOperands
40597
40598         int numDstRegOperands() override { return 1; }
40599         int numSrcRegOperands() override { return 2; }
40600
40601         int
40602         getOperandSize(int opIdx) override
40603         {
40604             switch (opIdx) {
40605               case 0: //src_0
40606                 return 2;
40607               case 1: //src_1
40608                 return 2;
40609               case 2: //sdst
40610                 return 8;
40611               default:
40612                 fatal("op idx %i out of bounds\n", opIdx);
40613                 return -1;
40614             }
40615         } // getOperandSize
40616
40617         bool
40618         isSrcOperand(int opIdx) override
40619         {
40620             switch (opIdx) {
40621               case 0: //src_0
40622                 return true;
40623               case 1: //src_1
40624                 return true;
40625               case 2: //sdst
40626                 return false;
40627               default:
40628                 fatal("op idx %i out of bounds\n", opIdx);
40629                 return false;
40630             }
40631         } // isSrcOperand
40632
40633         bool
40634         isDstOperand(int opIdx) override
40635         {
40636             switch (opIdx) {
40637               case 0: //src_0
40638                 return false;
40639               case 1: //src_1
40640                 return false;
40641               case 2: //sdst
40642                 return true;
40643               default:
40644                 fatal("op idx %i out of bounds\n", opIdx);
40645                 return false;
40646             }
40647         } // isDstOperand
40648
40649         void execute(GPUDynInstPtr) override;
40650     }; // Inst_VOP3__V_CMPX_F_U16
40651
40652     class Inst_VOP3__V_CMPX_LT_U16 : public Inst_VOP3
40653     {
40654       public:
40655         Inst_VOP3__V_CMPX_LT_U16(InFmt_VOP3*);
40656         ~Inst_VOP3__V_CMPX_LT_U16();
40657
40658         int
40659         getNumOperands() override
40660         {
40661             return numDstRegOperands() + numSrcRegOperands();
40662         } // getNumOperands
40663
40664         int numDstRegOperands() override { return 1; }
40665         int numSrcRegOperands() override { return 2; }
40666
40667         int
40668         getOperandSize(int opIdx) override
40669         {
40670             switch (opIdx) {
40671               case 0: //src_0
40672                 return 2;
40673               case 1: //src_1
40674                 return 2;
40675               case 2: //sdst
40676                 return 8;
40677               default:
40678                 fatal("op idx %i out of bounds\n", opIdx);
40679                 return -1;
40680             }
40681         } // getOperandSize
40682
40683         bool
40684         isSrcOperand(int opIdx) override
40685         {
40686             switch (opIdx) {
40687               case 0: //src_0
40688                 return true;
40689               case 1: //src_1
40690                 return true;
40691               case 2: //sdst
40692                 return false;
40693               default:
40694                 fatal("op idx %i out of bounds\n", opIdx);
40695                 return false;
40696             }
40697         } // isSrcOperand
40698
40699         bool
40700         isDstOperand(int opIdx) override
40701         {
40702             switch (opIdx) {
40703               case 0: //src_0
40704                 return false;
40705               case 1: //src_1
40706                 return false;
40707               case 2: //sdst
40708                 return true;
40709               default:
40710                 fatal("op idx %i out of bounds\n", opIdx);
40711                 return false;
40712             }
40713         } // isDstOperand
40714
40715         void execute(GPUDynInstPtr) override;
40716     }; // Inst_VOP3__V_CMPX_LT_U16
40717
40718     class Inst_VOP3__V_CMPX_EQ_U16 : public Inst_VOP3
40719     {
40720       public:
40721         Inst_VOP3__V_CMPX_EQ_U16(InFmt_VOP3*);
40722         ~Inst_VOP3__V_CMPX_EQ_U16();
40723
40724         int
40725         getNumOperands() override
40726         {
40727             return numDstRegOperands() + numSrcRegOperands();
40728         } // getNumOperands
40729
40730         int numDstRegOperands() override { return 1; }
40731         int numSrcRegOperands() override { return 2; }
40732
40733         int
40734         getOperandSize(int opIdx) override
40735         {
40736             switch (opIdx) {
40737               case 0: //src_0
40738                 return 2;
40739               case 1: //src_1
40740                 return 2;
40741               case 2: //sdst
40742                 return 8;
40743               default:
40744                 fatal("op idx %i out of bounds\n", opIdx);
40745                 return -1;
40746             }
40747         } // getOperandSize
40748
40749         bool
40750         isSrcOperand(int opIdx) override
40751         {
40752             switch (opIdx) {
40753               case 0: //src_0
40754                 return true;
40755               case 1: //src_1
40756                 return true;
40757               case 2: //sdst
40758                 return false;
40759               default:
40760                 fatal("op idx %i out of bounds\n", opIdx);
40761                 return false;
40762             }
40763         } // isSrcOperand
40764
40765         bool
40766         isDstOperand(int opIdx) override
40767         {
40768             switch (opIdx) {
40769               case 0: //src_0
40770                 return false;
40771               case 1: //src_1
40772                 return false;
40773               case 2: //sdst
40774                 return true;
40775               default:
40776                 fatal("op idx %i out of bounds\n", opIdx);
40777                 return false;
40778             }
40779         } // isDstOperand
40780
40781         void execute(GPUDynInstPtr) override;
40782     }; // Inst_VOP3__V_CMPX_EQ_U16
40783
40784     class Inst_VOP3__V_CMPX_LE_U16 : public Inst_VOP3
40785     {
40786       public:
40787         Inst_VOP3__V_CMPX_LE_U16(InFmt_VOP3*);
40788         ~Inst_VOP3__V_CMPX_LE_U16();
40789
40790         int
40791         getNumOperands() override
40792         {
40793             return numDstRegOperands() + numSrcRegOperands();
40794         } // getNumOperands
40795
40796         int numDstRegOperands() override { return 1; }
40797         int numSrcRegOperands() override { return 2; }
40798
40799         int
40800         getOperandSize(int opIdx) override
40801         {
40802             switch (opIdx) {
40803               case 0: //src_0
40804                 return 2;
40805               case 1: //src_1
40806                 return 2;
40807               case 2: //sdst
40808                 return 8;
40809               default:
40810                 fatal("op idx %i out of bounds\n", opIdx);
40811                 return -1;
40812             }
40813         } // getOperandSize
40814
40815         bool
40816         isSrcOperand(int opIdx) override
40817         {
40818             switch (opIdx) {
40819               case 0: //src_0
40820                 return true;
40821               case 1: //src_1
40822                 return true;
40823               case 2: //sdst
40824                 return false;
40825               default:
40826                 fatal("op idx %i out of bounds\n", opIdx);
40827                 return false;
40828             }
40829         } // isSrcOperand
40830
40831         bool
40832         isDstOperand(int opIdx) override
40833         {
40834             switch (opIdx) {
40835               case 0: //src_0
40836                 return false;
40837               case 1: //src_1
40838                 return false;
40839               case 2: //sdst
40840                 return true;
40841               default:
40842                 fatal("op idx %i out of bounds\n", opIdx);
40843                 return false;
40844             }
40845         } // isDstOperand
40846
40847         void execute(GPUDynInstPtr) override;
40848     }; // Inst_VOP3__V_CMPX_LE_U16
40849
40850     class Inst_VOP3__V_CMPX_GT_U16 : public Inst_VOP3
40851     {
40852       public:
40853         Inst_VOP3__V_CMPX_GT_U16(InFmt_VOP3*);
40854         ~Inst_VOP3__V_CMPX_GT_U16();
40855
40856         int
40857         getNumOperands() override
40858         {
40859             return numDstRegOperands() + numSrcRegOperands();
40860         } // getNumOperands
40861
40862         int numDstRegOperands() override { return 1; }
40863         int numSrcRegOperands() override { return 2; }
40864
40865         int
40866         getOperandSize(int opIdx) override
40867         {
40868             switch (opIdx) {
40869               case 0: //src_0
40870                 return 2;
40871               case 1: //src_1
40872                 return 2;
40873               case 2: //sdst
40874                 return 8;
40875               default:
40876                 fatal("op idx %i out of bounds\n", opIdx);
40877                 return -1;
40878             }
40879         } // getOperandSize
40880
40881         bool
40882         isSrcOperand(int opIdx) override
40883         {
40884             switch (opIdx) {
40885               case 0: //src_0
40886                 return true;
40887               case 1: //src_1
40888                 return true;
40889               case 2: //sdst
40890                 return false;
40891               default:
40892                 fatal("op idx %i out of bounds\n", opIdx);
40893                 return false;
40894             }
40895         } // isSrcOperand
40896
40897         bool
40898         isDstOperand(int opIdx) override
40899         {
40900             switch (opIdx) {
40901               case 0: //src_0
40902                 return false;
40903               case 1: //src_1
40904                 return false;
40905               case 2: //sdst
40906                 return true;
40907               default:
40908                 fatal("op idx %i out of bounds\n", opIdx);
40909                 return false;
40910             }
40911         } // isDstOperand
40912
40913         void execute(GPUDynInstPtr) override;
40914     }; // Inst_VOP3__V_CMPX_GT_U16
40915
40916     class Inst_VOP3__V_CMPX_NE_U16 : public Inst_VOP3
40917     {
40918       public:
40919         Inst_VOP3__V_CMPX_NE_U16(InFmt_VOP3*);
40920         ~Inst_VOP3__V_CMPX_NE_U16();
40921
40922         int
40923         getNumOperands() override
40924         {
40925             return numDstRegOperands() + numSrcRegOperands();
40926         } // getNumOperands
40927
40928         int numDstRegOperands() override { return 1; }
40929         int numSrcRegOperands() override { return 2; }
40930
40931         int
40932         getOperandSize(int opIdx) override
40933         {
40934             switch (opIdx) {
40935               case 0: //src_0
40936                 return 2;
40937               case 1: //src_1
40938                 return 2;
40939               case 2: //sdst
40940                 return 8;
40941               default:
40942                 fatal("op idx %i out of bounds\n", opIdx);
40943                 return -1;
40944             }
40945         } // getOperandSize
40946
40947         bool
40948         isSrcOperand(int opIdx) override
40949         {
40950             switch (opIdx) {
40951               case 0: //src_0
40952                 return true;
40953               case 1: //src_1
40954                 return true;
40955               case 2: //sdst
40956                 return false;
40957               default:
40958                 fatal("op idx %i out of bounds\n", opIdx);
40959                 return false;
40960             }
40961         } // isSrcOperand
40962
40963         bool
40964         isDstOperand(int opIdx) override
40965         {
40966             switch (opIdx) {
40967               case 0: //src_0
40968                 return false;
40969               case 1: //src_1
40970                 return false;
40971               case 2: //sdst
40972                 return true;
40973               default:
40974                 fatal("op idx %i out of bounds\n", opIdx);
40975                 return false;
40976             }
40977         } // isDstOperand
40978
40979         void execute(GPUDynInstPtr) override;
40980     }; // Inst_VOP3__V_CMPX_NE_U16
40981
40982     class Inst_VOP3__V_CMPX_GE_U16 : public Inst_VOP3
40983     {
40984       public:
40985         Inst_VOP3__V_CMPX_GE_U16(InFmt_VOP3*);
40986         ~Inst_VOP3__V_CMPX_GE_U16();
40987
40988         int
40989         getNumOperands() override
40990         {
40991             return numDstRegOperands() + numSrcRegOperands();
40992         } // getNumOperands
40993
40994         int numDstRegOperands() override { return 1; }
40995         int numSrcRegOperands() override { return 2; }
40996
40997         int
40998         getOperandSize(int opIdx) override
40999         {
41000             switch (opIdx) {
41001               case 0: //src_0
41002                 return 2;
41003               case 1: //src_1
41004                 return 2;
41005               case 2: //sdst
41006                 return 8;
41007               default:
41008                 fatal("op idx %i out of bounds\n", opIdx);
41009                 return -1;
41010             }
41011         } // getOperandSize
41012
41013         bool
41014         isSrcOperand(int opIdx) override
41015         {
41016             switch (opIdx) {
41017               case 0: //src_0
41018                 return true;
41019               case 1: //src_1
41020                 return true;
41021               case 2: //sdst
41022                 return false;
41023               default:
41024                 fatal("op idx %i out of bounds\n", opIdx);
41025                 return false;
41026             }
41027         } // isSrcOperand
41028
41029         bool
41030         isDstOperand(int opIdx) override
41031         {
41032             switch (opIdx) {
41033               case 0: //src_0
41034                 return false;
41035               case 1: //src_1
41036                 return false;
41037               case 2: //sdst
41038                 return true;
41039               default:
41040                 fatal("op idx %i out of bounds\n", opIdx);
41041                 return false;
41042             }
41043         } // isDstOperand
41044
41045         void execute(GPUDynInstPtr) override;
41046     }; // Inst_VOP3__V_CMPX_GE_U16
41047
41048     class Inst_VOP3__V_CMPX_T_U16 : public Inst_VOP3
41049     {
41050       public:
41051         Inst_VOP3__V_CMPX_T_U16(InFmt_VOP3*);
41052         ~Inst_VOP3__V_CMPX_T_U16();
41053
41054         int
41055         getNumOperands() override
41056         {
41057             return numDstRegOperands() + numSrcRegOperands();
41058         } // getNumOperands
41059
41060         int numDstRegOperands() override { return 1; }
41061         int numSrcRegOperands() override { return 2; }
41062
41063         int
41064         getOperandSize(int opIdx) override
41065         {
41066             switch (opIdx) {
41067               case 0: //src_0
41068                 return 2;
41069               case 1: //src_1
41070                 return 2;
41071               case 2: //sdst
41072                 return 8;
41073               default:
41074                 fatal("op idx %i out of bounds\n", opIdx);
41075                 return -1;
41076             }
41077         } // getOperandSize
41078
41079         bool
41080         isSrcOperand(int opIdx) override
41081         {
41082             switch (opIdx) {
41083               case 0: //src_0
41084                 return true;
41085               case 1: //src_1
41086                 return true;
41087               case 2: //sdst
41088                 return false;
41089               default:
41090                 fatal("op idx %i out of bounds\n", opIdx);
41091                 return false;
41092             }
41093         } // isSrcOperand
41094
41095         bool
41096         isDstOperand(int opIdx) override
41097         {
41098             switch (opIdx) {
41099               case 0: //src_0
41100                 return false;
41101               case 1: //src_1
41102                 return false;
41103               case 2: //sdst
41104                 return true;
41105               default:
41106                 fatal("op idx %i out of bounds\n", opIdx);
41107                 return false;
41108             }
41109         } // isDstOperand
41110
41111         void execute(GPUDynInstPtr) override;
41112     }; // Inst_VOP3__V_CMPX_T_U16
41113
41114     class Inst_VOP3__V_CMP_F_I32 : public Inst_VOP3
41115     {
41116       public:
41117         Inst_VOP3__V_CMP_F_I32(InFmt_VOP3*);
41118         ~Inst_VOP3__V_CMP_F_I32();
41119
41120         int
41121         getNumOperands() override
41122         {
41123             return numDstRegOperands() + numSrcRegOperands();
41124         } // getNumOperands
41125
41126         int numDstRegOperands() override { return 1; }
41127         int numSrcRegOperands() override { return 2; }
41128
41129         int
41130         getOperandSize(int opIdx) override
41131         {
41132             switch (opIdx) {
41133               case 0: //src_0
41134                 return 4;
41135               case 1: //src_1
41136                 return 4;
41137               case 2: //sdst
41138                 return 8;
41139               default:
41140                 fatal("op idx %i out of bounds\n", opIdx);
41141                 return -1;
41142             }
41143         } // getOperandSize
41144
41145         bool
41146         isSrcOperand(int opIdx) override
41147         {
41148             switch (opIdx) {
41149               case 0: //src_0
41150                 return true;
41151               case 1: //src_1
41152                 return true;
41153               case 2: //sdst
41154                 return false;
41155               default:
41156                 fatal("op idx %i out of bounds\n", opIdx);
41157                 return false;
41158             }
41159         } // isSrcOperand
41160
41161         bool
41162         isDstOperand(int opIdx) override
41163         {
41164             switch (opIdx) {
41165               case 0: //src_0
41166                 return false;
41167               case 1: //src_1
41168                 return false;
41169               case 2: //sdst
41170                 return true;
41171               default:
41172                 fatal("op idx %i out of bounds\n", opIdx);
41173                 return false;
41174             }
41175         } // isDstOperand
41176
41177         void execute(GPUDynInstPtr) override;
41178     }; // Inst_VOP3__V_CMP_F_I32
41179
41180     class Inst_VOP3__V_CMP_LT_I32 : public Inst_VOP3
41181     {
41182       public:
41183         Inst_VOP3__V_CMP_LT_I32(InFmt_VOP3*);
41184         ~Inst_VOP3__V_CMP_LT_I32();
41185
41186         int
41187         getNumOperands() override
41188         {
41189             return numDstRegOperands() + numSrcRegOperands();
41190         } // getNumOperands
41191
41192         int numDstRegOperands() override { return 1; }
41193         int numSrcRegOperands() override { return 2; }
41194
41195         int
41196         getOperandSize(int opIdx) override
41197         {
41198             switch (opIdx) {
41199               case 0: //src_0
41200                 return 4;
41201               case 1: //src_1
41202                 return 4;
41203               case 2: //sdst
41204                 return 8;
41205               default:
41206                 fatal("op idx %i out of bounds\n", opIdx);
41207                 return -1;
41208             }
41209         } // getOperandSize
41210
41211         bool
41212         isSrcOperand(int opIdx) override
41213         {
41214             switch (opIdx) {
41215               case 0: //src_0
41216                 return true;
41217               case 1: //src_1
41218                 return true;
41219               case 2: //sdst
41220                 return false;
41221               default:
41222                 fatal("op idx %i out of bounds\n", opIdx);
41223                 return false;
41224             }
41225         } // isSrcOperand
41226
41227         bool
41228         isDstOperand(int opIdx) override
41229         {
41230             switch (opIdx) {
41231               case 0: //src_0
41232                 return false;
41233               case 1: //src_1
41234                 return false;
41235               case 2: //sdst
41236                 return true;
41237               default:
41238                 fatal("op idx %i out of bounds\n", opIdx);
41239                 return false;
41240             }
41241         } // isDstOperand
41242
41243         void execute(GPUDynInstPtr) override;
41244     }; // Inst_VOP3__V_CMP_LT_I32
41245
41246     class Inst_VOP3__V_CMP_EQ_I32 : public Inst_VOP3
41247     {
41248       public:
41249         Inst_VOP3__V_CMP_EQ_I32(InFmt_VOP3*);
41250         ~Inst_VOP3__V_CMP_EQ_I32();
41251
41252         int
41253         getNumOperands() override
41254         {
41255             return numDstRegOperands() + numSrcRegOperands();
41256         } // getNumOperands
41257
41258         int numDstRegOperands() override { return 1; }
41259         int numSrcRegOperands() override { return 2; }
41260
41261         int
41262         getOperandSize(int opIdx) override
41263         {
41264             switch (opIdx) {
41265               case 0: //src_0
41266                 return 4;
41267               case 1: //src_1
41268                 return 4;
41269               case 2: //sdst
41270                 return 8;
41271               default:
41272                 fatal("op idx %i out of bounds\n", opIdx);
41273                 return -1;
41274             }
41275         } // getOperandSize
41276
41277         bool
41278         isSrcOperand(int opIdx) override
41279         {
41280             switch (opIdx) {
41281               case 0: //src_0
41282                 return true;
41283               case 1: //src_1
41284                 return true;
41285               case 2: //sdst
41286                 return false;
41287               default:
41288                 fatal("op idx %i out of bounds\n", opIdx);
41289                 return false;
41290             }
41291         } // isSrcOperand
41292
41293         bool
41294         isDstOperand(int opIdx) override
41295         {
41296             switch (opIdx) {
41297               case 0: //src_0
41298                 return false;
41299               case 1: //src_1
41300                 return false;
41301               case 2: //sdst
41302                 return true;
41303               default:
41304                 fatal("op idx %i out of bounds\n", opIdx);
41305                 return false;
41306             }
41307         } // isDstOperand
41308
41309         void execute(GPUDynInstPtr) override;
41310     }; // Inst_VOP3__V_CMP_EQ_I32
41311
41312     class Inst_VOP3__V_CMP_LE_I32 : public Inst_VOP3
41313     {
41314       public:
41315         Inst_VOP3__V_CMP_LE_I32(InFmt_VOP3*);
41316         ~Inst_VOP3__V_CMP_LE_I32();
41317
41318         int
41319         getNumOperands() override
41320         {
41321             return numDstRegOperands() + numSrcRegOperands();
41322         } // getNumOperands
41323
41324         int numDstRegOperands() override { return 1; }
41325         int numSrcRegOperands() override { return 2; }
41326
41327         int
41328         getOperandSize(int opIdx) override
41329         {
41330             switch (opIdx) {
41331               case 0: //src_0
41332                 return 4;
41333               case 1: //src_1
41334                 return 4;
41335               case 2: //sdst
41336                 return 8;
41337               default:
41338                 fatal("op idx %i out of bounds\n", opIdx);
41339                 return -1;
41340             }
41341         } // getOperandSize
41342
41343         bool
41344         isSrcOperand(int opIdx) override
41345         {
41346             switch (opIdx) {
41347               case 0: //src_0
41348                 return true;
41349               case 1: //src_1
41350                 return true;
41351               case 2: //sdst
41352                 return false;
41353               default:
41354                 fatal("op idx %i out of bounds\n", opIdx);
41355                 return false;
41356             }
41357         } // isSrcOperand
41358
41359         bool
41360         isDstOperand(int opIdx) override
41361         {
41362             switch (opIdx) {
41363               case 0: //src_0
41364                 return false;
41365               case 1: //src_1
41366                 return false;
41367               case 2: //sdst
41368                 return true;
41369               default:
41370                 fatal("op idx %i out of bounds\n", opIdx);
41371                 return false;
41372             }
41373         } // isDstOperand
41374
41375         void execute(GPUDynInstPtr) override;
41376     }; // Inst_VOP3__V_CMP_LE_I32
41377
41378     class Inst_VOP3__V_CMP_GT_I32 : public Inst_VOP3
41379     {
41380       public:
41381         Inst_VOP3__V_CMP_GT_I32(InFmt_VOP3*);
41382         ~Inst_VOP3__V_CMP_GT_I32();
41383
41384         int
41385         getNumOperands() override
41386         {
41387             return numDstRegOperands() + numSrcRegOperands();
41388         } // getNumOperands
41389
41390         int numDstRegOperands() override { return 1; }
41391         int numSrcRegOperands() override { return 2; }
41392
41393         int
41394         getOperandSize(int opIdx) override
41395         {
41396             switch (opIdx) {
41397               case 0: //src_0
41398                 return 4;
41399               case 1: //src_1
41400                 return 4;
41401               case 2: //sdst
41402                 return 8;
41403               default:
41404                 fatal("op idx %i out of bounds\n", opIdx);
41405                 return -1;
41406             }
41407         } // getOperandSize
41408
41409         bool
41410         isSrcOperand(int opIdx) override
41411         {
41412             switch (opIdx) {
41413               case 0: //src_0
41414                 return true;
41415               case 1: //src_1
41416                 return true;
41417               case 2: //sdst
41418                 return false;
41419               default:
41420                 fatal("op idx %i out of bounds\n", opIdx);
41421                 return false;
41422             }
41423         } // isSrcOperand
41424
41425         bool
41426         isDstOperand(int opIdx) override
41427         {
41428             switch (opIdx) {
41429               case 0: //src_0
41430                 return false;
41431               case 1: //src_1
41432                 return false;
41433               case 2: //sdst
41434                 return true;
41435               default:
41436                 fatal("op idx %i out of bounds\n", opIdx);
41437                 return false;
41438             }
41439         } // isDstOperand
41440
41441         void execute(GPUDynInstPtr) override;
41442     }; // Inst_VOP3__V_CMP_GT_I32
41443
41444     class Inst_VOP3__V_CMP_NE_I32 : public Inst_VOP3
41445     {
41446       public:
41447         Inst_VOP3__V_CMP_NE_I32(InFmt_VOP3*);
41448         ~Inst_VOP3__V_CMP_NE_I32();
41449
41450         int
41451         getNumOperands() override
41452         {
41453             return numDstRegOperands() + numSrcRegOperands();
41454         } // getNumOperands
41455
41456         int numDstRegOperands() override { return 1; }
41457         int numSrcRegOperands() override { return 2; }
41458
41459         int
41460         getOperandSize(int opIdx) override
41461         {
41462             switch (opIdx) {
41463               case 0: //src_0
41464                 return 4;
41465               case 1: //src_1
41466                 return 4;
41467               case 2: //sdst
41468                 return 8;
41469               default:
41470                 fatal("op idx %i out of bounds\n", opIdx);
41471                 return -1;
41472             }
41473         } // getOperandSize
41474
41475         bool
41476         isSrcOperand(int opIdx) override
41477         {
41478             switch (opIdx) {
41479               case 0: //src_0
41480                 return true;
41481               case 1: //src_1
41482                 return true;
41483               case 2: //sdst
41484                 return false;
41485               default:
41486                 fatal("op idx %i out of bounds\n", opIdx);
41487                 return false;
41488             }
41489         } // isSrcOperand
41490
41491         bool
41492         isDstOperand(int opIdx) override
41493         {
41494             switch (opIdx) {
41495               case 0: //src_0
41496                 return false;
41497               case 1: //src_1
41498                 return false;
41499               case 2: //sdst
41500                 return true;
41501               default:
41502                 fatal("op idx %i out of bounds\n", opIdx);
41503                 return false;
41504             }
41505         } // isDstOperand
41506
41507         void execute(GPUDynInstPtr) override;
41508     }; // Inst_VOP3__V_CMP_NE_I32
41509
41510     class Inst_VOP3__V_CMP_GE_I32 : public Inst_VOP3
41511     {
41512       public:
41513         Inst_VOP3__V_CMP_GE_I32(InFmt_VOP3*);
41514         ~Inst_VOP3__V_CMP_GE_I32();
41515
41516         int
41517         getNumOperands() override
41518         {
41519             return numDstRegOperands() + numSrcRegOperands();
41520         } // getNumOperands
41521
41522         int numDstRegOperands() override { return 1; }
41523         int numSrcRegOperands() override { return 2; }
41524
41525         int
41526         getOperandSize(int opIdx) override
41527         {
41528             switch (opIdx) {
41529               case 0: //src_0
41530                 return 4;
41531               case 1: //src_1
41532                 return 4;
41533               case 2: //sdst
41534                 return 8;
41535               default:
41536                 fatal("op idx %i out of bounds\n", opIdx);
41537                 return -1;
41538             }
41539         } // getOperandSize
41540
41541         bool
41542         isSrcOperand(int opIdx) override
41543         {
41544             switch (opIdx) {
41545               case 0: //src_0
41546                 return true;
41547               case 1: //src_1
41548                 return true;
41549               case 2: //sdst
41550                 return false;
41551               default:
41552                 fatal("op idx %i out of bounds\n", opIdx);
41553                 return false;
41554             }
41555         } // isSrcOperand
41556
41557         bool
41558         isDstOperand(int opIdx) override
41559         {
41560             switch (opIdx) {
41561               case 0: //src_0
41562                 return false;
41563               case 1: //src_1
41564                 return false;
41565               case 2: //sdst
41566                 return true;
41567               default:
41568                 fatal("op idx %i out of bounds\n", opIdx);
41569                 return false;
41570             }
41571         } // isDstOperand
41572
41573         void execute(GPUDynInstPtr) override;
41574     }; // Inst_VOP3__V_CMP_GE_I32
41575
41576     class Inst_VOP3__V_CMP_T_I32 : public Inst_VOP3
41577     {
41578       public:
41579         Inst_VOP3__V_CMP_T_I32(InFmt_VOP3*);
41580         ~Inst_VOP3__V_CMP_T_I32();
41581
41582         int
41583         getNumOperands() override
41584         {
41585             return numDstRegOperands() + numSrcRegOperands();
41586         } // getNumOperands
41587
41588         int numDstRegOperands() override { return 1; }
41589         int numSrcRegOperands() override { return 2; }
41590
41591         int
41592         getOperandSize(int opIdx) override
41593         {
41594             switch (opIdx) {
41595               case 0: //src_0
41596                 return 4;
41597               case 1: //src_1
41598                 return 4;
41599               case 2: //sdst
41600                 return 8;
41601               default:
41602                 fatal("op idx %i out of bounds\n", opIdx);
41603                 return -1;
41604             }
41605         } // getOperandSize
41606
41607         bool
41608         isSrcOperand(int opIdx) override
41609         {
41610             switch (opIdx) {
41611               case 0: //src_0
41612                 return true;
41613               case 1: //src_1
41614                 return true;
41615               case 2: //sdst
41616                 return false;
41617               default:
41618                 fatal("op idx %i out of bounds\n", opIdx);
41619                 return false;
41620             }
41621         } // isSrcOperand
41622
41623         bool
41624         isDstOperand(int opIdx) override
41625         {
41626             switch (opIdx) {
41627               case 0: //src_0
41628                 return false;
41629               case 1: //src_1
41630                 return false;
41631               case 2: //sdst
41632                 return true;
41633               default:
41634                 fatal("op idx %i out of bounds\n", opIdx);
41635                 return false;
41636             }
41637         } // isDstOperand
41638
41639         void execute(GPUDynInstPtr) override;
41640     }; // Inst_VOP3__V_CMP_T_I32
41641
41642     class Inst_VOP3__V_CMP_F_U32 : public Inst_VOP3
41643     {
41644       public:
41645         Inst_VOP3__V_CMP_F_U32(InFmt_VOP3*);
41646         ~Inst_VOP3__V_CMP_F_U32();
41647
41648         int
41649         getNumOperands() override
41650         {
41651             return numDstRegOperands() + numSrcRegOperands();
41652         } // getNumOperands
41653
41654         int numDstRegOperands() override { return 1; }
41655         int numSrcRegOperands() override { return 2; }
41656
41657         int
41658         getOperandSize(int opIdx) override
41659         {
41660             switch (opIdx) {
41661               case 0: //src_0
41662                 return 4;
41663               case 1: //src_1
41664                 return 4;
41665               case 2: //sdst
41666                 return 8;
41667               default:
41668                 fatal("op idx %i out of bounds\n", opIdx);
41669                 return -1;
41670             }
41671         } // getOperandSize
41672
41673         bool
41674         isSrcOperand(int opIdx) override
41675         {
41676             switch (opIdx) {
41677               case 0: //src_0
41678                 return true;
41679               case 1: //src_1
41680                 return true;
41681               case 2: //sdst
41682                 return false;
41683               default:
41684                 fatal("op idx %i out of bounds\n", opIdx);
41685                 return false;
41686             }
41687         } // isSrcOperand
41688
41689         bool
41690         isDstOperand(int opIdx) override
41691         {
41692             switch (opIdx) {
41693               case 0: //src_0
41694                 return false;
41695               case 1: //src_1
41696                 return false;
41697               case 2: //sdst
41698                 return true;
41699               default:
41700                 fatal("op idx %i out of bounds\n", opIdx);
41701                 return false;
41702             }
41703         } // isDstOperand
41704
41705         void execute(GPUDynInstPtr) override;
41706     }; // Inst_VOP3__V_CMP_F_U32
41707
41708     class Inst_VOP3__V_CMP_LT_U32 : public Inst_VOP3
41709     {
41710       public:
41711         Inst_VOP3__V_CMP_LT_U32(InFmt_VOP3*);
41712         ~Inst_VOP3__V_CMP_LT_U32();
41713
41714         int
41715         getNumOperands() override
41716         {
41717             return numDstRegOperands() + numSrcRegOperands();
41718         } // getNumOperands
41719
41720         int numDstRegOperands() override { return 1; }
41721         int numSrcRegOperands() override { return 2; }
41722
41723         int
41724         getOperandSize(int opIdx) override
41725         {
41726             switch (opIdx) {
41727               case 0: //src_0
41728                 return 4;
41729               case 1: //src_1
41730                 return 4;
41731               case 2: //sdst
41732                 return 8;
41733               default:
41734                 fatal("op idx %i out of bounds\n", opIdx);
41735                 return -1;
41736             }
41737         } // getOperandSize
41738
41739         bool
41740         isSrcOperand(int opIdx) override
41741         {
41742             switch (opIdx) {
41743               case 0: //src_0
41744                 return true;
41745               case 1: //src_1
41746                 return true;
41747               case 2: //sdst
41748                 return false;
41749               default:
41750                 fatal("op idx %i out of bounds\n", opIdx);
41751                 return false;
41752             }
41753         } // isSrcOperand
41754
41755         bool
41756         isDstOperand(int opIdx) override
41757         {
41758             switch (opIdx) {
41759               case 0: //src_0
41760                 return false;
41761               case 1: //src_1
41762                 return false;
41763               case 2: //sdst
41764                 return true;
41765               default:
41766                 fatal("op idx %i out of bounds\n", opIdx);
41767                 return false;
41768             }
41769         } // isDstOperand
41770
41771         void execute(GPUDynInstPtr) override;
41772     }; // Inst_VOP3__V_CMP_LT_U32
41773
41774     class Inst_VOP3__V_CMP_EQ_U32 : public Inst_VOP3
41775     {
41776       public:
41777         Inst_VOP3__V_CMP_EQ_U32(InFmt_VOP3*);
41778         ~Inst_VOP3__V_CMP_EQ_U32();
41779
41780         int
41781         getNumOperands() override
41782         {
41783             return numDstRegOperands() + numSrcRegOperands();
41784         } // getNumOperands
41785
41786         int numDstRegOperands() override { return 1; }
41787         int numSrcRegOperands() override { return 2; }
41788
41789         int
41790         getOperandSize(int opIdx) override
41791         {
41792             switch (opIdx) {
41793               case 0: //src_0
41794                 return 4;
41795               case 1: //src_1
41796                 return 4;
41797               case 2: //sdst
41798                 return 8;
41799               default:
41800                 fatal("op idx %i out of bounds\n", opIdx);
41801                 return -1;
41802             }
41803         } // getOperandSize
41804
41805         bool
41806         isSrcOperand(int opIdx) override
41807         {
41808             switch (opIdx) {
41809               case 0: //src_0
41810                 return true;
41811               case 1: //src_1
41812                 return true;
41813               case 2: //sdst
41814                 return false;
41815               default:
41816                 fatal("op idx %i out of bounds\n", opIdx);
41817                 return false;
41818             }
41819         } // isSrcOperand
41820
41821         bool
41822         isDstOperand(int opIdx) override
41823         {
41824             switch (opIdx) {
41825               case 0: //src_0
41826                 return false;
41827               case 1: //src_1
41828                 return false;
41829               case 2: //sdst
41830                 return true;
41831               default:
41832                 fatal("op idx %i out of bounds\n", opIdx);
41833                 return false;
41834             }
41835         } // isDstOperand
41836
41837         void execute(GPUDynInstPtr) override;
41838     }; // Inst_VOP3__V_CMP_EQ_U32
41839
41840     class Inst_VOP3__V_CMP_LE_U32 : public Inst_VOP3
41841     {
41842       public:
41843         Inst_VOP3__V_CMP_LE_U32(InFmt_VOP3*);
41844         ~Inst_VOP3__V_CMP_LE_U32();
41845
41846         int
41847         getNumOperands() override
41848         {
41849             return numDstRegOperands() + numSrcRegOperands();
41850         } // getNumOperands
41851
41852         int numDstRegOperands() override { return 1; }
41853         int numSrcRegOperands() override { return 2; }
41854
41855         int
41856         getOperandSize(int opIdx) override
41857         {
41858             switch (opIdx) {
41859               case 0: //src_0
41860                 return 4;
41861               case 1: //src_1
41862                 return 4;
41863               case 2: //sdst
41864                 return 8;
41865               default:
41866                 fatal("op idx %i out of bounds\n", opIdx);
41867                 return -1;
41868             }
41869         } // getOperandSize
41870
41871         bool
41872         isSrcOperand(int opIdx) override
41873         {
41874             switch (opIdx) {
41875               case 0: //src_0
41876                 return true;
41877               case 1: //src_1
41878                 return true;
41879               case 2: //sdst
41880                 return false;
41881               default:
41882                 fatal("op idx %i out of bounds\n", opIdx);
41883                 return false;
41884             }
41885         } // isSrcOperand
41886
41887         bool
41888         isDstOperand(int opIdx) override
41889         {
41890             switch (opIdx) {
41891               case 0: //src_0
41892                 return false;
41893               case 1: //src_1
41894                 return false;
41895               case 2: //sdst
41896                 return true;
41897               default:
41898                 fatal("op idx %i out of bounds\n", opIdx);
41899                 return false;
41900             }
41901         } // isDstOperand
41902
41903         void execute(GPUDynInstPtr) override;
41904     }; // Inst_VOP3__V_CMP_LE_U32
41905
41906     class Inst_VOP3__V_CMP_GT_U32 : public Inst_VOP3
41907     {
41908       public:
41909         Inst_VOP3__V_CMP_GT_U32(InFmt_VOP3*);
41910         ~Inst_VOP3__V_CMP_GT_U32();
41911
41912         int
41913         getNumOperands() override
41914         {
41915             return numDstRegOperands() + numSrcRegOperands();
41916         } // getNumOperands
41917
41918         int numDstRegOperands() override { return 1; }
41919         int numSrcRegOperands() override { return 2; }
41920
41921         int
41922         getOperandSize(int opIdx) override
41923         {
41924             switch (opIdx) {
41925               case 0: //src_0
41926                 return 4;
41927               case 1: //src_1
41928                 return 4;
41929               case 2: //sdst
41930                 return 8;
41931               default:
41932                 fatal("op idx %i out of bounds\n", opIdx);
41933                 return -1;
41934             }
41935         } // getOperandSize
41936
41937         bool
41938         isSrcOperand(int opIdx) override
41939         {
41940             switch (opIdx) {
41941               case 0: //src_0
41942                 return true;
41943               case 1: //src_1
41944                 return true;
41945               case 2: //sdst
41946                 return false;
41947               default:
41948                 fatal("op idx %i out of bounds\n", opIdx);
41949                 return false;
41950             }
41951         } // isSrcOperand
41952
41953         bool
41954         isDstOperand(int opIdx) override
41955         {
41956             switch (opIdx) {
41957               case 0: //src_0
41958                 return false;
41959               case 1: //src_1
41960                 return false;
41961               case 2: //sdst
41962                 return true;
41963               default:
41964                 fatal("op idx %i out of bounds\n", opIdx);
41965                 return false;
41966             }
41967         } // isDstOperand
41968
41969         void execute(GPUDynInstPtr) override;
41970     }; // Inst_VOP3__V_CMP_GT_U32
41971
41972     class Inst_VOP3__V_CMP_NE_U32 : public Inst_VOP3
41973     {
41974       public:
41975         Inst_VOP3__V_CMP_NE_U32(InFmt_VOP3*);
41976         ~Inst_VOP3__V_CMP_NE_U32();
41977
41978         int
41979         getNumOperands() override
41980         {
41981             return numDstRegOperands() + numSrcRegOperands();
41982         } // getNumOperands
41983
41984         int numDstRegOperands() override { return 1; }
41985         int numSrcRegOperands() override { return 2; }
41986
41987         int
41988         getOperandSize(int opIdx) override
41989         {
41990             switch (opIdx) {
41991               case 0: //src_0
41992                 return 4;
41993               case 1: //src_1
41994                 return 4;
41995               case 2: //sdst
41996                 return 8;
41997               default:
41998                 fatal("op idx %i out of bounds\n", opIdx);
41999                 return -1;
42000             }
42001         } // getOperandSize
42002
42003         bool
42004         isSrcOperand(int opIdx) override
42005         {
42006             switch (opIdx) {
42007               case 0: //src_0
42008                 return true;
42009               case 1: //src_1
42010                 return true;
42011               case 2: //sdst
42012                 return false;
42013               default:
42014                 fatal("op idx %i out of bounds\n", opIdx);
42015                 return false;
42016             }
42017         } // isSrcOperand
42018
42019         bool
42020         isDstOperand(int opIdx) override
42021         {
42022             switch (opIdx) {
42023               case 0: //src_0
42024                 return false;
42025               case 1: //src_1
42026                 return false;
42027               case 2: //sdst
42028                 return true;
42029               default:
42030                 fatal("op idx %i out of bounds\n", opIdx);
42031                 return false;
42032             }
42033         } // isDstOperand
42034
42035         void execute(GPUDynInstPtr) override;
42036     }; // Inst_VOP3__V_CMP_NE_U32
42037
42038     class Inst_VOP3__V_CMP_GE_U32 : public Inst_VOP3
42039     {
42040       public:
42041         Inst_VOP3__V_CMP_GE_U32(InFmt_VOP3*);
42042         ~Inst_VOP3__V_CMP_GE_U32();
42043
42044         int
42045         getNumOperands() override
42046         {
42047             return numDstRegOperands() + numSrcRegOperands();
42048         } // getNumOperands
42049
42050         int numDstRegOperands() override { return 1; }
42051         int numSrcRegOperands() override { return 2; }
42052
42053         int
42054         getOperandSize(int opIdx) override
42055         {
42056             switch (opIdx) {
42057               case 0: //src_0
42058                 return 4;
42059               case 1: //src_1
42060                 return 4;
42061               case 2: //sdst
42062                 return 8;
42063               default:
42064                 fatal("op idx %i out of bounds\n", opIdx);
42065                 return -1;
42066             }
42067         } // getOperandSize
42068
42069         bool
42070         isSrcOperand(int opIdx) override
42071         {
42072             switch (opIdx) {
42073               case 0: //src_0
42074                 return true;
42075               case 1: //src_1
42076                 return true;
42077               case 2: //sdst
42078                 return false;
42079               default:
42080                 fatal("op idx %i out of bounds\n", opIdx);
42081                 return false;
42082             }
42083         } // isSrcOperand
42084
42085         bool
42086         isDstOperand(int opIdx) override
42087         {
42088             switch (opIdx) {
42089               case 0: //src_0
42090                 return false;
42091               case 1: //src_1
42092                 return false;
42093               case 2: //sdst
42094                 return true;
42095               default:
42096                 fatal("op idx %i out of bounds\n", opIdx);
42097                 return false;
42098             }
42099         } // isDstOperand
42100
42101         void execute(GPUDynInstPtr) override;
42102     }; // Inst_VOP3__V_CMP_GE_U32
42103
42104     class Inst_VOP3__V_CMP_T_U32 : public Inst_VOP3
42105     {
42106       public:
42107         Inst_VOP3__V_CMP_T_U32(InFmt_VOP3*);
42108         ~Inst_VOP3__V_CMP_T_U32();
42109
42110         int
42111         getNumOperands() override
42112         {
42113             return numDstRegOperands() + numSrcRegOperands();
42114         } // getNumOperands
42115
42116         int numDstRegOperands() override { return 1; }
42117         int numSrcRegOperands() override { return 2; }
42118
42119         int
42120         getOperandSize(int opIdx) override
42121         {
42122             switch (opIdx) {
42123               case 0: //src_0
42124                 return 4;
42125               case 1: //src_1
42126                 return 4;
42127               case 2: //sdst
42128                 return 8;
42129               default:
42130                 fatal("op idx %i out of bounds\n", opIdx);
42131                 return -1;
42132             }
42133         } // getOperandSize
42134
42135         bool
42136         isSrcOperand(int opIdx) override
42137         {
42138             switch (opIdx) {
42139               case 0: //src_0
42140                 return true;
42141               case 1: //src_1
42142                 return true;
42143               case 2: //sdst
42144                 return false;
42145               default:
42146                 fatal("op idx %i out of bounds\n", opIdx);
42147                 return false;
42148             }
42149         } // isSrcOperand
42150
42151         bool
42152         isDstOperand(int opIdx) override
42153         {
42154             switch (opIdx) {
42155               case 0: //src_0
42156                 return false;
42157               case 1: //src_1
42158                 return false;
42159               case 2: //sdst
42160                 return true;
42161               default:
42162                 fatal("op idx %i out of bounds\n", opIdx);
42163                 return false;
42164             }
42165         } // isDstOperand
42166
42167         void execute(GPUDynInstPtr) override;
42168     }; // Inst_VOP3__V_CMP_T_U32
42169
42170     class Inst_VOP3__V_CMPX_F_I32 : public Inst_VOP3
42171     {
42172       public:
42173         Inst_VOP3__V_CMPX_F_I32(InFmt_VOP3*);
42174         ~Inst_VOP3__V_CMPX_F_I32();
42175
42176         int
42177         getNumOperands() override
42178         {
42179             return numDstRegOperands() + numSrcRegOperands();
42180         } // getNumOperands
42181
42182         int numDstRegOperands() override { return 1; }
42183         int numSrcRegOperands() override { return 2; }
42184
42185         int
42186         getOperandSize(int opIdx) override
42187         {
42188             switch (opIdx) {
42189               case 0: //src_0
42190                 return 4;
42191               case 1: //src_1
42192                 return 4;
42193               case 2: //sdst
42194                 return 8;
42195               default:
42196                 fatal("op idx %i out of bounds\n", opIdx);
42197                 return -1;
42198             }
42199         } // getOperandSize
42200
42201         bool
42202         isSrcOperand(int opIdx) override
42203         {
42204             switch (opIdx) {
42205               case 0: //src_0
42206                 return true;
42207               case 1: //src_1
42208                 return true;
42209               case 2: //sdst
42210                 return false;
42211               default:
42212                 fatal("op idx %i out of bounds\n", opIdx);
42213                 return false;
42214             }
42215         } // isSrcOperand
42216
42217         bool
42218         isDstOperand(int opIdx) override
42219         {
42220             switch (opIdx) {
42221               case 0: //src_0
42222                 return false;
42223               case 1: //src_1
42224                 return false;
42225               case 2: //sdst
42226                 return true;
42227               default:
42228                 fatal("op idx %i out of bounds\n", opIdx);
42229                 return false;
42230             }
42231         } // isDstOperand
42232
42233         void execute(GPUDynInstPtr) override;
42234     }; // Inst_VOP3__V_CMPX_F_I32
42235
42236     class Inst_VOP3__V_CMPX_LT_I32 : public Inst_VOP3
42237     {
42238       public:
42239         Inst_VOP3__V_CMPX_LT_I32(InFmt_VOP3*);
42240         ~Inst_VOP3__V_CMPX_LT_I32();
42241
42242         int
42243         getNumOperands() override
42244         {
42245             return numDstRegOperands() + numSrcRegOperands();
42246         } // getNumOperands
42247
42248         int numDstRegOperands() override { return 1; }
42249         int numSrcRegOperands() override { return 2; }
42250
42251         int
42252         getOperandSize(int opIdx) override
42253         {
42254             switch (opIdx) {
42255               case 0: //src_0
42256                 return 4;
42257               case 1: //src_1
42258                 return 4;
42259               case 2: //sdst
42260                 return 8;
42261               default:
42262                 fatal("op idx %i out of bounds\n", opIdx);
42263                 return -1;
42264             }
42265         } // getOperandSize
42266
42267         bool
42268         isSrcOperand(int opIdx) override
42269         {
42270             switch (opIdx) {
42271               case 0: //src_0
42272                 return true;
42273               case 1: //src_1
42274                 return true;
42275               case 2: //sdst
42276                 return false;
42277               default:
42278                 fatal("op idx %i out of bounds\n", opIdx);
42279                 return false;
42280             }
42281         } // isSrcOperand
42282
42283         bool
42284         isDstOperand(int opIdx) override
42285         {
42286             switch (opIdx) {
42287               case 0: //src_0
42288                 return false;
42289               case 1: //src_1
42290                 return false;
42291               case 2: //sdst
42292                 return true;
42293               default:
42294                 fatal("op idx %i out of bounds\n", opIdx);
42295                 return false;
42296             }
42297         } // isDstOperand
42298
42299         void execute(GPUDynInstPtr) override;
42300     }; // Inst_VOP3__V_CMPX_LT_I32
42301
42302     class Inst_VOP3__V_CMPX_EQ_I32 : public Inst_VOP3
42303     {
42304       public:
42305         Inst_VOP3__V_CMPX_EQ_I32(InFmt_VOP3*);
42306         ~Inst_VOP3__V_CMPX_EQ_I32();
42307
42308         int
42309         getNumOperands() override
42310         {
42311             return numDstRegOperands() + numSrcRegOperands();
42312         } // getNumOperands
42313
42314         int numDstRegOperands() override { return 1; }
42315         int numSrcRegOperands() override { return 2; }
42316
42317         int
42318         getOperandSize(int opIdx) override
42319         {
42320             switch (opIdx) {
42321               case 0: //src_0
42322                 return 4;
42323               case 1: //src_1
42324                 return 4;
42325               case 2: //sdst
42326                 return 8;
42327               default:
42328                 fatal("op idx %i out of bounds\n", opIdx);
42329                 return -1;
42330             }
42331         } // getOperandSize
42332
42333         bool
42334         isSrcOperand(int opIdx) override
42335         {
42336             switch (opIdx) {
42337               case 0: //src_0
42338                 return true;
42339               case 1: //src_1
42340                 return true;
42341               case 2: //sdst
42342                 return false;
42343               default:
42344                 fatal("op idx %i out of bounds\n", opIdx);
42345                 return false;
42346             }
42347         } // isSrcOperand
42348
42349         bool
42350         isDstOperand(int opIdx) override
42351         {
42352             switch (opIdx) {
42353               case 0: //src_0
42354                 return false;
42355               case 1: //src_1
42356                 return false;
42357               case 2: //sdst
42358                 return true;
42359               default:
42360                 fatal("op idx %i out of bounds\n", opIdx);
42361                 return false;
42362             }
42363         } // isDstOperand
42364
42365         void execute(GPUDynInstPtr) override;
42366     }; // Inst_VOP3__V_CMPX_EQ_I32
42367
42368     class Inst_VOP3__V_CMPX_LE_I32 : public Inst_VOP3
42369     {
42370       public:
42371         Inst_VOP3__V_CMPX_LE_I32(InFmt_VOP3*);
42372         ~Inst_VOP3__V_CMPX_LE_I32();
42373
42374         int
42375         getNumOperands() override
42376         {
42377             return numDstRegOperands() + numSrcRegOperands();
42378         } // getNumOperands
42379
42380         int numDstRegOperands() override { return 1; }
42381         int numSrcRegOperands() override { return 2; }
42382
42383         int
42384         getOperandSize(int opIdx) override
42385         {
42386             switch (opIdx) {
42387               case 0: //src_0
42388                 return 4;
42389               case 1: //src_1
42390                 return 4;
42391               case 2: //sdst
42392                 return 8;
42393               default:
42394                 fatal("op idx %i out of bounds\n", opIdx);
42395                 return -1;
42396             }
42397         } // getOperandSize
42398
42399         bool
42400         isSrcOperand(int opIdx) override
42401         {
42402             switch (opIdx) {
42403               case 0: //src_0
42404                 return true;
42405               case 1: //src_1
42406                 return true;
42407               case 2: //sdst
42408                 return false;
42409               default:
42410                 fatal("op idx %i out of bounds\n", opIdx);
42411                 return false;
42412             }
42413         } // isSrcOperand
42414
42415         bool
42416         isDstOperand(int opIdx) override
42417         {
42418             switch (opIdx) {
42419               case 0: //src_0
42420                 return false;
42421               case 1: //src_1
42422                 return false;
42423               case 2: //sdst
42424                 return true;
42425               default:
42426                 fatal("op idx %i out of bounds\n", opIdx);
42427                 return false;
42428             }
42429         } // isDstOperand
42430
42431         void execute(GPUDynInstPtr) override;
42432     }; // Inst_VOP3__V_CMPX_LE_I32
42433
42434     class Inst_VOP3__V_CMPX_GT_I32 : public Inst_VOP3
42435     {
42436       public:
42437         Inst_VOP3__V_CMPX_GT_I32(InFmt_VOP3*);
42438         ~Inst_VOP3__V_CMPX_GT_I32();
42439
42440         int
42441         getNumOperands() override
42442         {
42443             return numDstRegOperands() + numSrcRegOperands();
42444         } // getNumOperands
42445
42446         int numDstRegOperands() override { return 1; }
42447         int numSrcRegOperands() override { return 2; }
42448
42449         int
42450         getOperandSize(int opIdx) override
42451         {
42452             switch (opIdx) {
42453               case 0: //src_0
42454                 return 4;
42455               case 1: //src_1
42456                 return 4;
42457               case 2: //sdst
42458                 return 8;
42459               default:
42460                 fatal("op idx %i out of bounds\n", opIdx);
42461                 return -1;
42462             }
42463         } // getOperandSize
42464
42465         bool
42466         isSrcOperand(int opIdx) override
42467         {
42468             switch (opIdx) {
42469               case 0: //src_0
42470                 return true;
42471               case 1: //src_1
42472                 return true;
42473               case 2: //sdst
42474                 return false;
42475               default:
42476                 fatal("op idx %i out of bounds\n", opIdx);
42477                 return false;
42478             }
42479         } // isSrcOperand
42480
42481         bool
42482         isDstOperand(int opIdx) override
42483         {
42484             switch (opIdx) {
42485               case 0: //src_0
42486                 return false;
42487               case 1: //src_1
42488                 return false;
42489               case 2: //sdst
42490                 return true;
42491               default:
42492                 fatal("op idx %i out of bounds\n", opIdx);
42493                 return false;
42494             }
42495         } // isDstOperand
42496
42497         void execute(GPUDynInstPtr) override;
42498     }; // Inst_VOP3__V_CMPX_GT_I32
42499
42500     class Inst_VOP3__V_CMPX_NE_I32 : public Inst_VOP3
42501     {
42502       public:
42503         Inst_VOP3__V_CMPX_NE_I32(InFmt_VOP3*);
42504         ~Inst_VOP3__V_CMPX_NE_I32();
42505
42506         int
42507         getNumOperands() override
42508         {
42509             return numDstRegOperands() + numSrcRegOperands();
42510         } // getNumOperands
42511
42512         int numDstRegOperands() override { return 1; }
42513         int numSrcRegOperands() override { return 2; }
42514
42515         int
42516         getOperandSize(int opIdx) override
42517         {
42518             switch (opIdx) {
42519               case 0: //src_0
42520                 return 4;
42521               case 1: //src_1
42522                 return 4;
42523               case 2: //sdst
42524                 return 8;
42525               default:
42526                 fatal("op idx %i out of bounds\n", opIdx);
42527                 return -1;
42528             }
42529         } // getOperandSize
42530
42531         bool
42532         isSrcOperand(int opIdx) override
42533         {
42534             switch (opIdx) {
42535               case 0: //src_0
42536                 return true;
42537               case 1: //src_1
42538                 return true;
42539               case 2: //sdst
42540                 return false;
42541               default:
42542                 fatal("op idx %i out of bounds\n", opIdx);
42543                 return false;
42544             }
42545         } // isSrcOperand
42546
42547         bool
42548         isDstOperand(int opIdx) override
42549         {
42550             switch (opIdx) {
42551               case 0: //src_0
42552                 return false;
42553               case 1: //src_1
42554                 return false;
42555               case 2: //sdst
42556                 return true;
42557               default:
42558                 fatal("op idx %i out of bounds\n", opIdx);
42559                 return false;
42560             }
42561         } // isDstOperand
42562
42563         void execute(GPUDynInstPtr) override;
42564     }; // Inst_VOP3__V_CMPX_NE_I32
42565
42566     class Inst_VOP3__V_CMPX_GE_I32 : public Inst_VOP3
42567     {
42568       public:
42569         Inst_VOP3__V_CMPX_GE_I32(InFmt_VOP3*);
42570         ~Inst_VOP3__V_CMPX_GE_I32();
42571
42572         int
42573         getNumOperands() override
42574         {
42575             return numDstRegOperands() + numSrcRegOperands();
42576         } // getNumOperands
42577
42578         int numDstRegOperands() override { return 1; }
42579         int numSrcRegOperands() override { return 2; }
42580
42581         int
42582         getOperandSize(int opIdx) override
42583         {
42584             switch (opIdx) {
42585               case 0: //src_0
42586                 return 4;
42587               case 1: //src_1
42588                 return 4;
42589               case 2: //sdst
42590                 return 8;
42591               default:
42592                 fatal("op idx %i out of bounds\n", opIdx);
42593                 return -1;
42594             }
42595         } // getOperandSize
42596
42597         bool
42598         isSrcOperand(int opIdx) override
42599         {
42600             switch (opIdx) {
42601               case 0: //src_0
42602                 return true;
42603               case 1: //src_1
42604                 return true;
42605               case 2: //sdst
42606                 return false;
42607               default:
42608                 fatal("op idx %i out of bounds\n", opIdx);
42609                 return false;
42610             }
42611         } // isSrcOperand
42612
42613         bool
42614         isDstOperand(int opIdx) override
42615         {
42616             switch (opIdx) {
42617               case 0: //src_0
42618                 return false;
42619               case 1: //src_1
42620                 return false;
42621               case 2: //sdst
42622                 return true;
42623               default:
42624                 fatal("op idx %i out of bounds\n", opIdx);
42625                 return false;
42626             }
42627         } // isDstOperand
42628
42629         void execute(GPUDynInstPtr) override;
42630     }; // Inst_VOP3__V_CMPX_GE_I32
42631
42632     class Inst_VOP3__V_CMPX_T_I32 : public Inst_VOP3
42633     {
42634       public:
42635         Inst_VOP3__V_CMPX_T_I32(InFmt_VOP3*);
42636         ~Inst_VOP3__V_CMPX_T_I32();
42637
42638         int
42639         getNumOperands() override
42640         {
42641             return numDstRegOperands() + numSrcRegOperands();
42642         } // getNumOperands
42643
42644         int numDstRegOperands() override { return 1; }
42645         int numSrcRegOperands() override { return 2; }
42646
42647         int
42648         getOperandSize(int opIdx) override
42649         {
42650             switch (opIdx) {
42651               case 0: //src_0
42652                 return 4;
42653               case 1: //src_1
42654                 return 4;
42655               case 2: //sdst
42656                 return 8;
42657               default:
42658                 fatal("op idx %i out of bounds\n", opIdx);
42659                 return -1;
42660             }
42661         } // getOperandSize
42662
42663         bool
42664         isSrcOperand(int opIdx) override
42665         {
42666             switch (opIdx) {
42667               case 0: //src_0
42668                 return true;
42669               case 1: //src_1
42670                 return true;
42671               case 2: //sdst
42672                 return false;
42673               default:
42674                 fatal("op idx %i out of bounds\n", opIdx);
42675                 return false;
42676             }
42677         } // isSrcOperand
42678
42679         bool
42680         isDstOperand(int opIdx) override
42681         {
42682             switch (opIdx) {
42683               case 0: //src_0
42684                 return false;
42685               case 1: //src_1
42686                 return false;
42687               case 2: //sdst
42688                 return true;
42689               default:
42690                 fatal("op idx %i out of bounds\n", opIdx);
42691                 return false;
42692             }
42693         } // isDstOperand
42694
42695         void execute(GPUDynInstPtr) override;
42696     }; // Inst_VOP3__V_CMPX_T_I32
42697
42698     class Inst_VOP3__V_CMPX_F_U32 : public Inst_VOP3
42699     {
42700       public:
42701         Inst_VOP3__V_CMPX_F_U32(InFmt_VOP3*);
42702         ~Inst_VOP3__V_CMPX_F_U32();
42703
42704         int
42705         getNumOperands() override
42706         {
42707             return numDstRegOperands() + numSrcRegOperands();
42708         } // getNumOperands
42709
42710         int numDstRegOperands() override { return 1; }
42711         int numSrcRegOperands() override { return 2; }
42712
42713         int
42714         getOperandSize(int opIdx) override
42715         {
42716             switch (opIdx) {
42717               case 0: //src_0
42718                 return 4;
42719               case 1: //src_1
42720                 return 4;
42721               case 2: //sdst
42722                 return 8;
42723               default:
42724                 fatal("op idx %i out of bounds\n", opIdx);
42725                 return -1;
42726             }
42727         } // getOperandSize
42728
42729         bool
42730         isSrcOperand(int opIdx) override
42731         {
42732             switch (opIdx) {
42733               case 0: //src_0
42734                 return true;
42735               case 1: //src_1
42736                 return true;
42737               case 2: //sdst
42738                 return false;
42739               default:
42740                 fatal("op idx %i out of bounds\n", opIdx);
42741                 return false;
42742             }
42743         } // isSrcOperand
42744
42745         bool
42746         isDstOperand(int opIdx) override
42747         {
42748             switch (opIdx) {
42749               case 0: //src_0
42750                 return false;
42751               case 1: //src_1
42752                 return false;
42753               case 2: //sdst
42754                 return true;
42755               default:
42756                 fatal("op idx %i out of bounds\n", opIdx);
42757                 return false;
42758             }
42759         } // isDstOperand
42760
42761         void execute(GPUDynInstPtr) override;
42762     }; // Inst_VOP3__V_CMPX_F_U32
42763
42764     class Inst_VOP3__V_CMPX_LT_U32 : public Inst_VOP3
42765     {
42766       public:
42767         Inst_VOP3__V_CMPX_LT_U32(InFmt_VOP3*);
42768         ~Inst_VOP3__V_CMPX_LT_U32();
42769
42770         int
42771         getNumOperands() override
42772         {
42773             return numDstRegOperands() + numSrcRegOperands();
42774         } // getNumOperands
42775
42776         int numDstRegOperands() override { return 1; }
42777         int numSrcRegOperands() override { return 2; }
42778
42779         int
42780         getOperandSize(int opIdx) override
42781         {
42782             switch (opIdx) {
42783               case 0: //src_0
42784                 return 4;
42785               case 1: //src_1
42786                 return 4;
42787               case 2: //sdst
42788                 return 8;
42789               default:
42790                 fatal("op idx %i out of bounds\n", opIdx);
42791                 return -1;
42792             }
42793         } // getOperandSize
42794
42795         bool
42796         isSrcOperand(int opIdx) override
42797         {
42798             switch (opIdx) {
42799               case 0: //src_0
42800                 return true;
42801               case 1: //src_1
42802                 return true;
42803               case 2: //sdst
42804                 return false;
42805               default:
42806                 fatal("op idx %i out of bounds\n", opIdx);
42807                 return false;
42808             }
42809         } // isSrcOperand
42810
42811         bool
42812         isDstOperand(int opIdx) override
42813         {
42814             switch (opIdx) {
42815               case 0: //src_0
42816                 return false;
42817               case 1: //src_1
42818                 return false;
42819               case 2: //sdst
42820                 return true;
42821               default:
42822                 fatal("op idx %i out of bounds\n", opIdx);
42823                 return false;
42824             }
42825         } // isDstOperand
42826
42827         void execute(GPUDynInstPtr) override;
42828     }; // Inst_VOP3__V_CMPX_LT_U32
42829
42830     class Inst_VOP3__V_CMPX_EQ_U32 : public Inst_VOP3
42831     {
42832       public:
42833         Inst_VOP3__V_CMPX_EQ_U32(InFmt_VOP3*);
42834         ~Inst_VOP3__V_CMPX_EQ_U32();
42835
42836         int
42837         getNumOperands() override
42838         {
42839             return numDstRegOperands() + numSrcRegOperands();
42840         } // getNumOperands
42841
42842         int numDstRegOperands() override { return 1; }
42843         int numSrcRegOperands() override { return 2; }
42844
42845         int
42846         getOperandSize(int opIdx) override
42847         {
42848             switch (opIdx) {
42849               case 0: //src_0
42850                 return 4;
42851               case 1: //src_1
42852                 return 4;
42853               case 2: //sdst
42854                 return 8;
42855               default:
42856                 fatal("op idx %i out of bounds\n", opIdx);
42857                 return -1;
42858             }
42859         } // getOperandSize
42860
42861         bool
42862         isSrcOperand(int opIdx) override
42863         {
42864             switch (opIdx) {
42865               case 0: //src_0
42866                 return true;
42867               case 1: //src_1
42868                 return true;
42869               case 2: //sdst
42870                 return false;
42871               default:
42872                 fatal("op idx %i out of bounds\n", opIdx);
42873                 return false;
42874             }
42875         } // isSrcOperand
42876
42877         bool
42878         isDstOperand(int opIdx) override
42879         {
42880             switch (opIdx) {
42881               case 0: //src_0
42882                 return false;
42883               case 1: //src_1
42884                 return false;
42885               case 2: //sdst
42886                 return true;
42887               default:
42888                 fatal("op idx %i out of bounds\n", opIdx);
42889                 return false;
42890             }
42891         } // isDstOperand
42892
42893         void execute(GPUDynInstPtr) override;
42894     }; // Inst_VOP3__V_CMPX_EQ_U32
42895
42896     class Inst_VOP3__V_CMPX_LE_U32 : public Inst_VOP3
42897     {
42898       public:
42899         Inst_VOP3__V_CMPX_LE_U32(InFmt_VOP3*);
42900         ~Inst_VOP3__V_CMPX_LE_U32();
42901
42902         int
42903         getNumOperands() override
42904         {
42905             return numDstRegOperands() + numSrcRegOperands();
42906         } // getNumOperands
42907
42908         int numDstRegOperands() override { return 1; }
42909         int numSrcRegOperands() override { return 2; }
42910
42911         int
42912         getOperandSize(int opIdx) override
42913         {
42914             switch (opIdx) {
42915               case 0: //src_0
42916                 return 4;
42917               case 1: //src_1
42918                 return 4;
42919               case 2: //sdst
42920                 return 8;
42921               default:
42922                 fatal("op idx %i out of bounds\n", opIdx);
42923                 return -1;
42924             }
42925         } // getOperandSize
42926
42927         bool
42928         isSrcOperand(int opIdx) override
42929         {
42930             switch (opIdx) {
42931               case 0: //src_0
42932                 return true;
42933               case 1: //src_1
42934                 return true;
42935               case 2: //sdst
42936                 return false;
42937               default:
42938                 fatal("op idx %i out of bounds\n", opIdx);
42939                 return false;
42940             }
42941         } // isSrcOperand
42942
42943         bool
42944         isDstOperand(int opIdx) override
42945         {
42946             switch (opIdx) {
42947               case 0: //src_0
42948                 return false;
42949               case 1: //src_1
42950                 return false;
42951               case 2: //sdst
42952                 return true;
42953               default:
42954                 fatal("op idx %i out of bounds\n", opIdx);
42955                 return false;
42956             }
42957         } // isDstOperand
42958
42959         void execute(GPUDynInstPtr) override;
42960     }; // Inst_VOP3__V_CMPX_LE_U32
42961
42962     class Inst_VOP3__V_CMPX_GT_U32 : public Inst_VOP3
42963     {
42964       public:
42965         Inst_VOP3__V_CMPX_GT_U32(InFmt_VOP3*);
42966         ~Inst_VOP3__V_CMPX_GT_U32();
42967
42968         int
42969         getNumOperands() override
42970         {
42971             return numDstRegOperands() + numSrcRegOperands();
42972         } // getNumOperands
42973
42974         int numDstRegOperands() override { return 1; }
42975         int numSrcRegOperands() override { return 2; }
42976
42977         int
42978         getOperandSize(int opIdx) override
42979         {
42980             switch (opIdx) {
42981               case 0: //src_0
42982                 return 4;
42983               case 1: //src_1
42984                 return 4;
42985               case 2: //sdst
42986                 return 8;
42987               default:
42988                 fatal("op idx %i out of bounds\n", opIdx);
42989                 return -1;
42990             }
42991         } // getOperandSize
42992
42993         bool
42994         isSrcOperand(int opIdx) override
42995         {
42996             switch (opIdx) {
42997               case 0: //src_0
42998                 return true;
42999               case 1: //src_1
43000                 return true;
43001               case 2: //sdst
43002                 return false;
43003               default:
43004                 fatal("op idx %i out of bounds\n", opIdx);
43005                 return false;
43006             }
43007         } // isSrcOperand
43008
43009         bool
43010         isDstOperand(int opIdx) override
43011         {
43012             switch (opIdx) {
43013               case 0: //src_0
43014                 return false;
43015               case 1: //src_1
43016                 return false;
43017               case 2: //sdst
43018                 return true;
43019               default:
43020                 fatal("op idx %i out of bounds\n", opIdx);
43021                 return false;
43022             }
43023         } // isDstOperand
43024
43025         void execute(GPUDynInstPtr) override;
43026     }; // Inst_VOP3__V_CMPX_GT_U32
43027
43028     class Inst_VOP3__V_CMPX_NE_U32 : public Inst_VOP3
43029     {
43030       public:
43031         Inst_VOP3__V_CMPX_NE_U32(InFmt_VOP3*);
43032         ~Inst_VOP3__V_CMPX_NE_U32();
43033
43034         int
43035         getNumOperands() override
43036         {
43037             return numDstRegOperands() + numSrcRegOperands();
43038         } // getNumOperands
43039
43040         int numDstRegOperands() override { return 1; }
43041         int numSrcRegOperands() override { return 2; }
43042
43043         int
43044         getOperandSize(int opIdx) override
43045         {
43046             switch (opIdx) {
43047               case 0: //src_0
43048                 return 4;
43049               case 1: //src_1
43050                 return 4;
43051               case 2: //sdst
43052                 return 8;
43053               default:
43054                 fatal("op idx %i out of bounds\n", opIdx);
43055                 return -1;
43056             }
43057         } // getOperandSize
43058
43059         bool
43060         isSrcOperand(int opIdx) override
43061         {
43062             switch (opIdx) {
43063               case 0: //src_0
43064                 return true;
43065               case 1: //src_1
43066                 return true;
43067               case 2: //sdst
43068                 return false;
43069               default:
43070                 fatal("op idx %i out of bounds\n", opIdx);
43071                 return false;
43072             }
43073         } // isSrcOperand
43074
43075         bool
43076         isDstOperand(int opIdx) override
43077         {
43078             switch (opIdx) {
43079               case 0: //src_0
43080                 return false;
43081               case 1: //src_1
43082                 return false;
43083               case 2: //sdst
43084                 return true;
43085               default:
43086                 fatal("op idx %i out of bounds\n", opIdx);
43087                 return false;
43088             }
43089         } // isDstOperand
43090
43091         void execute(GPUDynInstPtr) override;
43092     }; // Inst_VOP3__V_CMPX_NE_U32
43093
43094     class Inst_VOP3__V_CMPX_GE_U32 : public Inst_VOP3
43095     {
43096       public:
43097         Inst_VOP3__V_CMPX_GE_U32(InFmt_VOP3*);
43098         ~Inst_VOP3__V_CMPX_GE_U32();
43099
43100         int
43101         getNumOperands() override
43102         {
43103             return numDstRegOperands() + numSrcRegOperands();
43104         } // getNumOperands
43105
43106         int numDstRegOperands() override { return 1; }
43107         int numSrcRegOperands() override { return 2; }
43108
43109         int
43110         getOperandSize(int opIdx) override
43111         {
43112             switch (opIdx) {
43113               case 0: //src_0
43114                 return 4;
43115               case 1: //src_1
43116                 return 4;
43117               case 2: //sdst
43118                 return 8;
43119               default:
43120                 fatal("op idx %i out of bounds\n", opIdx);
43121                 return -1;
43122             }
43123         } // getOperandSize
43124
43125         bool
43126         isSrcOperand(int opIdx) override
43127         {
43128             switch (opIdx) {
43129               case 0: //src_0
43130                 return true;
43131               case 1: //src_1
43132                 return true;
43133               case 2: //sdst
43134                 return false;
43135               default:
43136                 fatal("op idx %i out of bounds\n", opIdx);
43137                 return false;
43138             }
43139         } // isSrcOperand
43140
43141         bool
43142         isDstOperand(int opIdx) override
43143         {
43144             switch (opIdx) {
43145               case 0: //src_0
43146                 return false;
43147               case 1: //src_1
43148                 return false;
43149               case 2: //sdst
43150                 return true;
43151               default:
43152                 fatal("op idx %i out of bounds\n", opIdx);
43153                 return false;
43154             }
43155         } // isDstOperand
43156
43157         void execute(GPUDynInstPtr) override;
43158     }; // Inst_VOP3__V_CMPX_GE_U32
43159
43160     class Inst_VOP3__V_CMPX_T_U32 : public Inst_VOP3
43161     {
43162       public:
43163         Inst_VOP3__V_CMPX_T_U32(InFmt_VOP3*);
43164         ~Inst_VOP3__V_CMPX_T_U32();
43165
43166         int
43167         getNumOperands() override
43168         {
43169             return numDstRegOperands() + numSrcRegOperands();
43170         } // getNumOperands
43171
43172         int numDstRegOperands() override { return 1; }
43173         int numSrcRegOperands() override { return 2; }
43174
43175         int
43176         getOperandSize(int opIdx) override
43177         {
43178             switch (opIdx) {
43179               case 0: //src_0
43180                 return 4;
43181               case 1: //src_1
43182                 return 4;
43183               case 2: //sdst
43184                 return 8;
43185               default:
43186                 fatal("op idx %i out of bounds\n", opIdx);
43187                 return -1;
43188             }
43189         } // getOperandSize
43190
43191         bool
43192         isSrcOperand(int opIdx) override
43193         {
43194             switch (opIdx) {
43195               case 0: //src_0
43196                 return true;
43197               case 1: //src_1
43198                 return true;
43199               case 2: //sdst
43200                 return false;
43201               default:
43202                 fatal("op idx %i out of bounds\n", opIdx);
43203                 return false;
43204             }
43205         } // isSrcOperand
43206
43207         bool
43208         isDstOperand(int opIdx) override
43209         {
43210             switch (opIdx) {
43211               case 0: //src_0
43212                 return false;
43213               case 1: //src_1
43214                 return false;
43215               case 2: //sdst
43216                 return true;
43217               default:
43218                 fatal("op idx %i out of bounds\n", opIdx);
43219                 return false;
43220             }
43221         } // isDstOperand
43222
43223         void execute(GPUDynInstPtr) override;
43224     }; // Inst_VOP3__V_CMPX_T_U32
43225
43226     class Inst_VOP3__V_CMP_F_I64 : public Inst_VOP3
43227     {
43228       public:
43229         Inst_VOP3__V_CMP_F_I64(InFmt_VOP3*);
43230         ~Inst_VOP3__V_CMP_F_I64();
43231
43232         int
43233         getNumOperands() override
43234         {
43235             return numDstRegOperands() + numSrcRegOperands();
43236         } // getNumOperands
43237
43238         int numDstRegOperands() override { return 1; }
43239         int numSrcRegOperands() override { return 2; }
43240
43241         int
43242         getOperandSize(int opIdx) override
43243         {
43244             switch (opIdx) {
43245               case 0: //src_0
43246                 return 8;
43247               case 1: //src_1
43248                 return 8;
43249               case 2: //sdst
43250                 return 8;
43251               default:
43252                 fatal("op idx %i out of bounds\n", opIdx);
43253                 return -1;
43254             }
43255         } // getOperandSize
43256
43257         bool
43258         isSrcOperand(int opIdx) override
43259         {
43260             switch (opIdx) {
43261               case 0: //src_0
43262                 return true;
43263               case 1: //src_1
43264                 return true;
43265               case 2: //sdst
43266                 return false;
43267               default:
43268                 fatal("op idx %i out of bounds\n", opIdx);
43269                 return false;
43270             }
43271         } // isSrcOperand
43272
43273         bool
43274         isDstOperand(int opIdx) override
43275         {
43276             switch (opIdx) {
43277               case 0: //src_0
43278                 return false;
43279               case 1: //src_1
43280                 return false;
43281               case 2: //sdst
43282                 return true;
43283               default:
43284                 fatal("op idx %i out of bounds\n", opIdx);
43285                 return false;
43286             }
43287         } // isDstOperand
43288
43289         void execute(GPUDynInstPtr) override;
43290     }; // Inst_VOP3__V_CMP_F_I64
43291
43292     class Inst_VOP3__V_CMP_LT_I64 : public Inst_VOP3
43293     {
43294       public:
43295         Inst_VOP3__V_CMP_LT_I64(InFmt_VOP3*);
43296         ~Inst_VOP3__V_CMP_LT_I64();
43297
43298         int
43299         getNumOperands() override
43300         {
43301             return numDstRegOperands() + numSrcRegOperands();
43302         } // getNumOperands
43303
43304         int numDstRegOperands() override { return 1; }
43305         int numSrcRegOperands() override { return 2; }
43306
43307         int
43308         getOperandSize(int opIdx) override
43309         {
43310             switch (opIdx) {
43311               case 0: //src_0
43312                 return 8;
43313               case 1: //src_1
43314                 return 8;
43315               case 2: //sdst
43316                 return 8;
43317               default:
43318                 fatal("op idx %i out of bounds\n", opIdx);
43319                 return -1;
43320             }
43321         } // getOperandSize
43322
43323         bool
43324         isSrcOperand(int opIdx) override
43325         {
43326             switch (opIdx) {
43327               case 0: //src_0
43328                 return true;
43329               case 1: //src_1
43330                 return true;
43331               case 2: //sdst
43332                 return false;
43333               default:
43334                 fatal("op idx %i out of bounds\n", opIdx);
43335                 return false;
43336             }
43337         } // isSrcOperand
43338
43339         bool
43340         isDstOperand(int opIdx) override
43341         {
43342             switch (opIdx) {
43343               case 0: //src_0
43344                 return false;
43345               case 1: //src_1
43346                 return false;
43347               case 2: //sdst
43348                 return true;
43349               default:
43350                 fatal("op idx %i out of bounds\n", opIdx);
43351                 return false;
43352             }
43353         } // isDstOperand
43354
43355         void execute(GPUDynInstPtr) override;
43356     }; // Inst_VOP3__V_CMP_LT_I64
43357
43358     class Inst_VOP3__V_CMP_EQ_I64 : public Inst_VOP3
43359     {
43360       public:
43361         Inst_VOP3__V_CMP_EQ_I64(InFmt_VOP3*);
43362         ~Inst_VOP3__V_CMP_EQ_I64();
43363
43364         int
43365         getNumOperands() override
43366         {
43367             return numDstRegOperands() + numSrcRegOperands();
43368         } // getNumOperands
43369
43370         int numDstRegOperands() override { return 1; }
43371         int numSrcRegOperands() override { return 2; }
43372
43373         int
43374         getOperandSize(int opIdx) override
43375         {
43376             switch (opIdx) {
43377               case 0: //src_0
43378                 return 8;
43379               case 1: //src_1
43380                 return 8;
43381               case 2: //sdst
43382                 return 8;
43383               default:
43384                 fatal("op idx %i out of bounds\n", opIdx);
43385                 return -1;
43386             }
43387         } // getOperandSize
43388
43389         bool
43390         isSrcOperand(int opIdx) override
43391         {
43392             switch (opIdx) {
43393               case 0: //src_0
43394                 return true;
43395               case 1: //src_1
43396                 return true;
43397               case 2: //sdst
43398                 return false;
43399               default:
43400                 fatal("op idx %i out of bounds\n", opIdx);
43401                 return false;
43402             }
43403         } // isSrcOperand
43404
43405         bool
43406         isDstOperand(int opIdx) override
43407         {
43408             switch (opIdx) {
43409               case 0: //src_0
43410                 return false;
43411               case 1: //src_1
43412                 return false;
43413               case 2: //sdst
43414                 return true;
43415               default:
43416                 fatal("op idx %i out of bounds\n", opIdx);
43417                 return false;
43418             }
43419         } // isDstOperand
43420
43421         void execute(GPUDynInstPtr) override;
43422     }; // Inst_VOP3__V_CMP_EQ_I64
43423
43424     class Inst_VOP3__V_CMP_LE_I64 : public Inst_VOP3
43425     {
43426       public:
43427         Inst_VOP3__V_CMP_LE_I64(InFmt_VOP3*);
43428         ~Inst_VOP3__V_CMP_LE_I64();
43429
43430         int
43431         getNumOperands() override
43432         {
43433             return numDstRegOperands() + numSrcRegOperands();
43434         } // getNumOperands
43435
43436         int numDstRegOperands() override { return 1; }
43437         int numSrcRegOperands() override { return 2; }
43438
43439         int
43440         getOperandSize(int opIdx) override
43441         {
43442             switch (opIdx) {
43443               case 0: //src_0
43444                 return 8;
43445               case 1: //src_1
43446                 return 8;
43447               case 2: //sdst
43448                 return 8;
43449               default:
43450                 fatal("op idx %i out of bounds\n", opIdx);
43451                 return -1;
43452             }
43453         } // getOperandSize
43454
43455         bool
43456         isSrcOperand(int opIdx) override
43457         {
43458             switch (opIdx) {
43459               case 0: //src_0
43460                 return true;
43461               case 1: //src_1
43462                 return true;
43463               case 2: //sdst
43464                 return false;
43465               default:
43466                 fatal("op idx %i out of bounds\n", opIdx);
43467                 return false;
43468             }
43469         } // isSrcOperand
43470
43471         bool
43472         isDstOperand(int opIdx) override
43473         {
43474             switch (opIdx) {
43475               case 0: //src_0
43476                 return false;
43477               case 1: //src_1
43478                 return false;
43479               case 2: //sdst
43480                 return true;
43481               default:
43482                 fatal("op idx %i out of bounds\n", opIdx);
43483                 return false;
43484             }
43485         } // isDstOperand
43486
43487         void execute(GPUDynInstPtr) override;
43488     }; // Inst_VOP3__V_CMP_LE_I64
43489
43490     class Inst_VOP3__V_CMP_GT_I64 : public Inst_VOP3
43491     {
43492       public:
43493         Inst_VOP3__V_CMP_GT_I64(InFmt_VOP3*);
43494         ~Inst_VOP3__V_CMP_GT_I64();
43495
43496         int
43497         getNumOperands() override
43498         {
43499             return numDstRegOperands() + numSrcRegOperands();
43500         } // getNumOperands
43501
43502         int numDstRegOperands() override { return 1; }
43503         int numSrcRegOperands() override { return 2; }
43504
43505         int
43506         getOperandSize(int opIdx) override
43507         {
43508             switch (opIdx) {
43509               case 0: //src_0
43510                 return 8;
43511               case 1: //src_1
43512                 return 8;
43513               case 2: //sdst
43514                 return 8;
43515               default:
43516                 fatal("op idx %i out of bounds\n", opIdx);
43517                 return -1;
43518             }
43519         } // getOperandSize
43520
43521         bool
43522         isSrcOperand(int opIdx) override
43523         {
43524             switch (opIdx) {
43525               case 0: //src_0
43526                 return true;
43527               case 1: //src_1
43528                 return true;
43529               case 2: //sdst
43530                 return false;
43531               default:
43532                 fatal("op idx %i out of bounds\n", opIdx);
43533                 return false;
43534             }
43535         } // isSrcOperand
43536
43537         bool
43538         isDstOperand(int opIdx) override
43539         {
43540             switch (opIdx) {
43541               case 0: //src_0
43542                 return false;
43543               case 1: //src_1
43544                 return false;
43545               case 2: //sdst
43546                 return true;
43547               default:
43548                 fatal("op idx %i out of bounds\n", opIdx);
43549                 return false;
43550             }
43551         } // isDstOperand
43552
43553         void execute(GPUDynInstPtr) override;
43554     }; // Inst_VOP3__V_CMP_GT_I64
43555
43556     class Inst_VOP3__V_CMP_NE_I64 : public Inst_VOP3
43557     {
43558       public:
43559         Inst_VOP3__V_CMP_NE_I64(InFmt_VOP3*);
43560         ~Inst_VOP3__V_CMP_NE_I64();
43561
43562         int
43563         getNumOperands() override
43564         {
43565             return numDstRegOperands() + numSrcRegOperands();
43566         } // getNumOperands
43567
43568         int numDstRegOperands() override { return 1; }
43569         int numSrcRegOperands() override { return 2; }
43570
43571         int
43572         getOperandSize(int opIdx) override
43573         {
43574             switch (opIdx) {
43575               case 0: //src_0
43576                 return 8;
43577               case 1: //src_1
43578                 return 8;
43579               case 2: //sdst
43580                 return 8;
43581               default:
43582                 fatal("op idx %i out of bounds\n", opIdx);
43583                 return -1;
43584             }
43585         } // getOperandSize
43586
43587         bool
43588         isSrcOperand(int opIdx) override
43589         {
43590             switch (opIdx) {
43591               case 0: //src_0
43592                 return true;
43593               case 1: //src_1
43594                 return true;
43595               case 2: //sdst
43596                 return false;
43597               default:
43598                 fatal("op idx %i out of bounds\n", opIdx);
43599                 return false;
43600             }
43601         } // isSrcOperand
43602
43603         bool
43604         isDstOperand(int opIdx) override
43605         {
43606             switch (opIdx) {
43607               case 0: //src_0
43608                 return false;
43609               case 1: //src_1
43610                 return false;
43611               case 2: //sdst
43612                 return true;
43613               default:
43614                 fatal("op idx %i out of bounds\n", opIdx);
43615                 return false;
43616             }
43617         } // isDstOperand
43618
43619         void execute(GPUDynInstPtr) override;
43620     }; // Inst_VOP3__V_CMP_NE_I64
43621
43622     class Inst_VOP3__V_CMP_GE_I64 : public Inst_VOP3
43623     {
43624       public:
43625         Inst_VOP3__V_CMP_GE_I64(InFmt_VOP3*);
43626         ~Inst_VOP3__V_CMP_GE_I64();
43627
43628         int
43629         getNumOperands() override
43630         {
43631             return numDstRegOperands() + numSrcRegOperands();
43632         } // getNumOperands
43633
43634         int numDstRegOperands() override { return 1; }
43635         int numSrcRegOperands() override { return 2; }
43636
43637         int
43638         getOperandSize(int opIdx) override
43639         {
43640             switch (opIdx) {
43641               case 0: //src_0
43642                 return 8;
43643               case 1: //src_1
43644                 return 8;
43645               case 2: //sdst
43646                 return 8;
43647               default:
43648                 fatal("op idx %i out of bounds\n", opIdx);
43649                 return -1;
43650             }
43651         } // getOperandSize
43652
43653         bool
43654         isSrcOperand(int opIdx) override
43655         {
43656             switch (opIdx) {
43657               case 0: //src_0
43658                 return true;
43659               case 1: //src_1
43660                 return true;
43661               case 2: //sdst
43662                 return false;
43663               default:
43664                 fatal("op idx %i out of bounds\n", opIdx);
43665                 return false;
43666             }
43667         } // isSrcOperand
43668
43669         bool
43670         isDstOperand(int opIdx) override
43671         {
43672             switch (opIdx) {
43673               case 0: //src_0
43674                 return false;
43675               case 1: //src_1
43676                 return false;
43677               case 2: //sdst
43678                 return true;
43679               default:
43680                 fatal("op idx %i out of bounds\n", opIdx);
43681                 return false;
43682             }
43683         } // isDstOperand
43684
43685         void execute(GPUDynInstPtr) override;
43686     }; // Inst_VOP3__V_CMP_GE_I64
43687
43688     class Inst_VOP3__V_CMP_T_I64 : public Inst_VOP3
43689     {
43690       public:
43691         Inst_VOP3__V_CMP_T_I64(InFmt_VOP3*);
43692         ~Inst_VOP3__V_CMP_T_I64();
43693
43694         int
43695         getNumOperands() override
43696         {
43697             return numDstRegOperands() + numSrcRegOperands();
43698         } // getNumOperands
43699
43700         int numDstRegOperands() override { return 1; }
43701         int numSrcRegOperands() override { return 2; }
43702
43703         int
43704         getOperandSize(int opIdx) override
43705         {
43706             switch (opIdx) {
43707               case 0: //src_0
43708                 return 8;
43709               case 1: //src_1
43710                 return 8;
43711               case 2: //sdst
43712                 return 8;
43713               default:
43714                 fatal("op idx %i out of bounds\n", opIdx);
43715                 return -1;
43716             }
43717         } // getOperandSize
43718
43719         bool
43720         isSrcOperand(int opIdx) override
43721         {
43722             switch (opIdx) {
43723               case 0: //src_0
43724                 return true;
43725               case 1: //src_1
43726                 return true;
43727               case 2: //sdst
43728                 return false;
43729               default:
43730                 fatal("op idx %i out of bounds\n", opIdx);
43731                 return false;
43732             }
43733         } // isSrcOperand
43734
43735         bool
43736         isDstOperand(int opIdx) override
43737         {
43738             switch (opIdx) {
43739               case 0: //src_0
43740                 return false;
43741               case 1: //src_1
43742                 return false;
43743               case 2: //sdst
43744                 return true;
43745               default:
43746                 fatal("op idx %i out of bounds\n", opIdx);
43747                 return false;
43748             }
43749         } // isDstOperand
43750
43751         void execute(GPUDynInstPtr) override;
43752     }; // Inst_VOP3__V_CMP_T_I64
43753
43754     class Inst_VOP3__V_CMP_F_U64 : public Inst_VOP3
43755     {
43756       public:
43757         Inst_VOP3__V_CMP_F_U64(InFmt_VOP3*);
43758         ~Inst_VOP3__V_CMP_F_U64();
43759
43760         int
43761         getNumOperands() override
43762         {
43763             return numDstRegOperands() + numSrcRegOperands();
43764         } // getNumOperands
43765
43766         int numDstRegOperands() override { return 1; }
43767         int numSrcRegOperands() override { return 2; }
43768
43769         int
43770         getOperandSize(int opIdx) override
43771         {
43772             switch (opIdx) {
43773               case 0: //src_0
43774                 return 8;
43775               case 1: //src_1
43776                 return 8;
43777               case 2: //sdst
43778                 return 8;
43779               default:
43780                 fatal("op idx %i out of bounds\n", opIdx);
43781                 return -1;
43782             }
43783         } // getOperandSize
43784
43785         bool
43786         isSrcOperand(int opIdx) override
43787         {
43788             switch (opIdx) {
43789               case 0: //src_0
43790                 return true;
43791               case 1: //src_1
43792                 return true;
43793               case 2: //sdst
43794                 return false;
43795               default:
43796                 fatal("op idx %i out of bounds\n", opIdx);
43797                 return false;
43798             }
43799         } // isSrcOperand
43800
43801         bool
43802         isDstOperand(int opIdx) override
43803         {
43804             switch (opIdx) {
43805               case 0: //src_0
43806                 return false;
43807               case 1: //src_1
43808                 return false;
43809               case 2: //sdst
43810                 return true;
43811               default:
43812                 fatal("op idx %i out of bounds\n", opIdx);
43813                 return false;
43814             }
43815         } // isDstOperand
43816
43817         void execute(GPUDynInstPtr) override;
43818     }; // Inst_VOP3__V_CMP_F_U64
43819
43820     class Inst_VOP3__V_CMP_LT_U64 : public Inst_VOP3
43821     {
43822       public:
43823         Inst_VOP3__V_CMP_LT_U64(InFmt_VOP3*);
43824         ~Inst_VOP3__V_CMP_LT_U64();
43825
43826         int
43827         getNumOperands() override
43828         {
43829             return numDstRegOperands() + numSrcRegOperands();
43830         } // getNumOperands
43831
43832         int numDstRegOperands() override { return 1; }
43833         int numSrcRegOperands() override { return 2; }
43834
43835         int
43836         getOperandSize(int opIdx) override
43837         {
43838             switch (opIdx) {
43839               case 0: //src_0
43840                 return 8;
43841               case 1: //src_1
43842                 return 8;
43843               case 2: //sdst
43844                 return 8;
43845               default:
43846                 fatal("op idx %i out of bounds\n", opIdx);
43847                 return -1;
43848             }
43849         } // getOperandSize
43850
43851         bool
43852         isSrcOperand(int opIdx) override
43853         {
43854             switch (opIdx) {
43855               case 0: //src_0
43856                 return true;
43857               case 1: //src_1
43858                 return true;
43859               case 2: //sdst
43860                 return false;
43861               default:
43862                 fatal("op idx %i out of bounds\n", opIdx);
43863                 return false;
43864             }
43865         } // isSrcOperand
43866
43867         bool
43868         isDstOperand(int opIdx) override
43869         {
43870             switch (opIdx) {
43871               case 0: //src_0
43872                 return false;
43873               case 1: //src_1
43874                 return false;
43875               case 2: //sdst
43876                 return true;
43877               default:
43878                 fatal("op idx %i out of bounds\n", opIdx);
43879                 return false;
43880             }
43881         } // isDstOperand
43882
43883         void execute(GPUDynInstPtr) override;
43884     }; // Inst_VOP3__V_CMP_LT_U64
43885
43886     class Inst_VOP3__V_CMP_EQ_U64 : public Inst_VOP3
43887     {
43888       public:
43889         Inst_VOP3__V_CMP_EQ_U64(InFmt_VOP3*);
43890         ~Inst_VOP3__V_CMP_EQ_U64();
43891
43892         int
43893         getNumOperands() override
43894         {
43895             return numDstRegOperands() + numSrcRegOperands();
43896         } // getNumOperands
43897
43898         int numDstRegOperands() override { return 1; }
43899         int numSrcRegOperands() override { return 2; }
43900
43901         int
43902         getOperandSize(int opIdx) override
43903         {
43904             switch (opIdx) {
43905               case 0: //src_0
43906                 return 8;
43907               case 1: //src_1
43908                 return 8;
43909               case 2: //sdst
43910                 return 8;
43911               default:
43912                 fatal("op idx %i out of bounds\n", opIdx);
43913                 return -1;
43914             }
43915         } // getOperandSize
43916
43917         bool
43918         isSrcOperand(int opIdx) override
43919         {
43920             switch (opIdx) {
43921               case 0: //src_0
43922                 return true;
43923               case 1: //src_1
43924                 return true;
43925               case 2: //sdst
43926                 return false;
43927               default:
43928                 fatal("op idx %i out of bounds\n", opIdx);
43929                 return false;
43930             }
43931         } // isSrcOperand
43932
43933         bool
43934         isDstOperand(int opIdx) override
43935         {
43936             switch (opIdx) {
43937               case 0: //src_0
43938                 return false;
43939               case 1: //src_1
43940                 return false;
43941               case 2: //sdst
43942                 return true;
43943               default:
43944                 fatal("op idx %i out of bounds\n", opIdx);
43945                 return false;
43946             }
43947         } // isDstOperand
43948
43949         void execute(GPUDynInstPtr) override;
43950     }; // Inst_VOP3__V_CMP_EQ_U64
43951
43952     class Inst_VOP3__V_CMP_LE_U64 : public Inst_VOP3
43953     {
43954       public:
43955         Inst_VOP3__V_CMP_LE_U64(InFmt_VOP3*);
43956         ~Inst_VOP3__V_CMP_LE_U64();
43957
43958         int
43959         getNumOperands() override
43960         {
43961             return numDstRegOperands() + numSrcRegOperands();
43962         } // getNumOperands
43963
43964         int numDstRegOperands() override { return 1; }
43965         int numSrcRegOperands() override { return 2; }
43966
43967         int
43968         getOperandSize(int opIdx) override
43969         {
43970             switch (opIdx) {
43971               case 0: //src_0
43972                 return 8;
43973               case 1: //src_1
43974                 return 8;
43975               case 2: //sdst
43976                 return 8;
43977               default:
43978                 fatal("op idx %i out of bounds\n", opIdx);
43979                 return -1;
43980             }
43981         } // getOperandSize
43982
43983         bool
43984         isSrcOperand(int opIdx) override
43985         {
43986             switch (opIdx) {
43987               case 0: //src_0
43988                 return true;
43989               case 1: //src_1
43990                 return true;
43991               case 2: //sdst
43992                 return false;
43993               default:
43994                 fatal("op idx %i out of bounds\n", opIdx);
43995                 return false;
43996             }
43997         } // isSrcOperand
43998
43999         bool
44000         isDstOperand(int opIdx) override
44001         {
44002             switch (opIdx) {
44003               case 0: //src_0
44004                 return false;
44005               case 1: //src_1
44006                 return false;
44007               case 2: //sdst
44008                 return true;
44009               default:
44010                 fatal("op idx %i out of bounds\n", opIdx);
44011                 return false;
44012             }
44013         } // isDstOperand
44014
44015         void execute(GPUDynInstPtr) override;
44016     }; // Inst_VOP3__V_CMP_LE_U64
44017
44018     class Inst_VOP3__V_CMP_GT_U64 : public Inst_VOP3
44019     {
44020       public:
44021         Inst_VOP3__V_CMP_GT_U64(InFmt_VOP3*);
44022         ~Inst_VOP3__V_CMP_GT_U64();
44023
44024         int
44025         getNumOperands() override
44026         {
44027             return numDstRegOperands() + numSrcRegOperands();
44028         } // getNumOperands
44029
44030         int numDstRegOperands() override { return 1; }
44031         int numSrcRegOperands() override { return 2; }
44032
44033         int
44034         getOperandSize(int opIdx) override
44035         {
44036             switch (opIdx) {
44037               case 0: //src_0
44038                 return 8;
44039               case 1: //src_1
44040                 return 8;
44041               case 2: //sdst
44042                 return 8;
44043               default:
44044                 fatal("op idx %i out of bounds\n", opIdx);
44045                 return -1;
44046             }
44047         } // getOperandSize
44048
44049         bool
44050         isSrcOperand(int opIdx) override
44051         {
44052             switch (opIdx) {
44053               case 0: //src_0
44054                 return true;
44055               case 1: //src_1
44056                 return true;
44057               case 2: //sdst
44058                 return false;
44059               default:
44060                 fatal("op idx %i out of bounds\n", opIdx);
44061                 return false;
44062             }
44063         } // isSrcOperand
44064
44065         bool
44066         isDstOperand(int opIdx) override
44067         {
44068             switch (opIdx) {
44069               case 0: //src_0
44070                 return false;
44071               case 1: //src_1
44072                 return false;
44073               case 2: //sdst
44074                 return true;
44075               default:
44076                 fatal("op idx %i out of bounds\n", opIdx);
44077                 return false;
44078             }
44079         } // isDstOperand
44080
44081         void execute(GPUDynInstPtr) override;
44082     }; // Inst_VOP3__V_CMP_GT_U64
44083
44084     class Inst_VOP3__V_CMP_NE_U64 : public Inst_VOP3
44085     {
44086       public:
44087         Inst_VOP3__V_CMP_NE_U64(InFmt_VOP3*);
44088         ~Inst_VOP3__V_CMP_NE_U64();
44089
44090         int
44091         getNumOperands() override
44092         {
44093             return numDstRegOperands() + numSrcRegOperands();
44094         } // getNumOperands
44095
44096         int numDstRegOperands() override { return 1; }
44097         int numSrcRegOperands() override { return 2; }
44098
44099         int
44100         getOperandSize(int opIdx) override
44101         {
44102             switch (opIdx) {
44103               case 0: //src_0
44104                 return 8;
44105               case 1: //src_1
44106                 return 8;
44107               case 2: //sdst
44108                 return 8;
44109               default:
44110                 fatal("op idx %i out of bounds\n", opIdx);
44111                 return -1;
44112             }
44113         } // getOperandSize
44114
44115         bool
44116         isSrcOperand(int opIdx) override
44117         {
44118             switch (opIdx) {
44119               case 0: //src_0
44120                 return true;
44121               case 1: //src_1
44122                 return true;
44123               case 2: //sdst
44124                 return false;
44125               default:
44126                 fatal("op idx %i out of bounds\n", opIdx);
44127                 return false;
44128             }
44129         } // isSrcOperand
44130
44131         bool
44132         isDstOperand(int opIdx) override
44133         {
44134             switch (opIdx) {
44135               case 0: //src_0
44136                 return false;
44137               case 1: //src_1
44138                 return false;
44139               case 2: //sdst
44140                 return true;
44141               default:
44142                 fatal("op idx %i out of bounds\n", opIdx);
44143                 return false;
44144             }
44145         } // isDstOperand
44146
44147         void execute(GPUDynInstPtr) override;
44148     }; // Inst_VOP3__V_CMP_NE_U64
44149
44150     class Inst_VOP3__V_CMP_GE_U64 : public Inst_VOP3
44151     {
44152       public:
44153         Inst_VOP3__V_CMP_GE_U64(InFmt_VOP3*);
44154         ~Inst_VOP3__V_CMP_GE_U64();
44155
44156         int
44157         getNumOperands() override
44158         {
44159             return numDstRegOperands() + numSrcRegOperands();
44160         } // getNumOperands
44161
44162         int numDstRegOperands() override { return 1; }
44163         int numSrcRegOperands() override { return 2; }
44164
44165         int
44166         getOperandSize(int opIdx) override
44167         {
44168             switch (opIdx) {
44169               case 0: //src_0
44170                 return 8;
44171               case 1: //src_1
44172                 return 8;
44173               case 2: //sdst
44174                 return 8;
44175               default:
44176                 fatal("op idx %i out of bounds\n", opIdx);
44177                 return -1;
44178             }
44179         } // getOperandSize
44180
44181         bool
44182         isSrcOperand(int opIdx) override
44183         {
44184             switch (opIdx) {
44185               case 0: //src_0
44186                 return true;
44187               case 1: //src_1
44188                 return true;
44189               case 2: //sdst
44190                 return false;
44191               default:
44192                 fatal("op idx %i out of bounds\n", opIdx);
44193                 return false;
44194             }
44195         } // isSrcOperand
44196
44197         bool
44198         isDstOperand(int opIdx) override
44199         {
44200             switch (opIdx) {
44201               case 0: //src_0
44202                 return false;
44203               case 1: //src_1
44204                 return false;
44205               case 2: //sdst
44206                 return true;
44207               default:
44208                 fatal("op idx %i out of bounds\n", opIdx);
44209                 return false;
44210             }
44211         } // isDstOperand
44212
44213         void execute(GPUDynInstPtr) override;
44214     }; // Inst_VOP3__V_CMP_GE_U64
44215
44216     class Inst_VOP3__V_CMP_T_U64 : public Inst_VOP3
44217     {
44218       public:
44219         Inst_VOP3__V_CMP_T_U64(InFmt_VOP3*);
44220         ~Inst_VOP3__V_CMP_T_U64();
44221
44222         int
44223         getNumOperands() override
44224         {
44225             return numDstRegOperands() + numSrcRegOperands();
44226         } // getNumOperands
44227
44228         int numDstRegOperands() override { return 1; }
44229         int numSrcRegOperands() override { return 2; }
44230
44231         int
44232         getOperandSize(int opIdx) override
44233         {
44234             switch (opIdx) {
44235               case 0: //src_0
44236                 return 8;
44237               case 1: //src_1
44238                 return 8;
44239               case 2: //sdst
44240                 return 8;
44241               default:
44242                 fatal("op idx %i out of bounds\n", opIdx);
44243                 return -1;
44244             }
44245         } // getOperandSize
44246
44247         bool
44248         isSrcOperand(int opIdx) override
44249         {
44250             switch (opIdx) {
44251               case 0: //src_0
44252                 return true;
44253               case 1: //src_1
44254                 return true;
44255               case 2: //sdst
44256                 return false;
44257               default:
44258                 fatal("op idx %i out of bounds\n", opIdx);
44259                 return false;
44260             }
44261         } // isSrcOperand
44262
44263         bool
44264         isDstOperand(int opIdx) override
44265         {
44266             switch (opIdx) {
44267               case 0: //src_0
44268                 return false;
44269               case 1: //src_1
44270                 return false;
44271               case 2: //sdst
44272                 return true;
44273               default:
44274                 fatal("op idx %i out of bounds\n", opIdx);
44275                 return false;
44276             }
44277         } // isDstOperand
44278
44279         void execute(GPUDynInstPtr) override;
44280     }; // Inst_VOP3__V_CMP_T_U64
44281
44282     class Inst_VOP3__V_CMPX_F_I64 : public Inst_VOP3
44283     {
44284       public:
44285         Inst_VOP3__V_CMPX_F_I64(InFmt_VOP3*);
44286         ~Inst_VOP3__V_CMPX_F_I64();
44287
44288         int
44289         getNumOperands() override
44290         {
44291             return numDstRegOperands() + numSrcRegOperands();
44292         } // getNumOperands
44293
44294         int numDstRegOperands() override { return 1; }
44295         int numSrcRegOperands() override { return 2; }
44296
44297         int
44298         getOperandSize(int opIdx) override
44299         {
44300             switch (opIdx) {
44301               case 0: //src_0
44302                 return 8;
44303               case 1: //src_1
44304                 return 8;
44305               case 2: //sdst
44306                 return 8;
44307               default:
44308                 fatal("op idx %i out of bounds\n", opIdx);
44309                 return -1;
44310             }
44311         } // getOperandSize
44312
44313         bool
44314         isSrcOperand(int opIdx) override
44315         {
44316             switch (opIdx) {
44317               case 0: //src_0
44318                 return true;
44319               case 1: //src_1
44320                 return true;
44321               case 2: //sdst
44322                 return false;
44323               default:
44324                 fatal("op idx %i out of bounds\n", opIdx);
44325                 return false;
44326             }
44327         } // isSrcOperand
44328
44329         bool
44330         isDstOperand(int opIdx) override
44331         {
44332             switch (opIdx) {
44333               case 0: //src_0
44334                 return false;
44335               case 1: //src_1
44336                 return false;
44337               case 2: //sdst
44338                 return true;
44339               default:
44340                 fatal("op idx %i out of bounds\n", opIdx);
44341                 return false;
44342             }
44343         } // isDstOperand
44344
44345         void execute(GPUDynInstPtr) override;
44346     }; // Inst_VOP3__V_CMPX_F_I64
44347
44348     class Inst_VOP3__V_CMPX_LT_I64 : public Inst_VOP3
44349     {
44350       public:
44351         Inst_VOP3__V_CMPX_LT_I64(InFmt_VOP3*);
44352         ~Inst_VOP3__V_CMPX_LT_I64();
44353
44354         int
44355         getNumOperands() override
44356         {
44357             return numDstRegOperands() + numSrcRegOperands();
44358         } // getNumOperands
44359
44360         int numDstRegOperands() override { return 1; }
44361         int numSrcRegOperands() override { return 2; }
44362
44363         int
44364         getOperandSize(int opIdx) override
44365         {
44366             switch (opIdx) {
44367               case 0: //src_0
44368                 return 8;
44369               case 1: //src_1
44370                 return 8;
44371               case 2: //sdst
44372                 return 8;
44373               default:
44374                 fatal("op idx %i out of bounds\n", opIdx);
44375                 return -1;
44376             }
44377         } // getOperandSize
44378
44379         bool
44380         isSrcOperand(int opIdx) override
44381         {
44382             switch (opIdx) {
44383               case 0: //src_0
44384                 return true;
44385               case 1: //src_1
44386                 return true;
44387               case 2: //sdst
44388                 return false;
44389               default:
44390                 fatal("op idx %i out of bounds\n", opIdx);
44391                 return false;
44392             }
44393         } // isSrcOperand
44394
44395         bool
44396         isDstOperand(int opIdx) override
44397         {
44398             switch (opIdx) {
44399               case 0: //src_0
44400                 return false;
44401               case 1: //src_1
44402                 return false;
44403               case 2: //sdst
44404                 return true;
44405               default:
44406                 fatal("op idx %i out of bounds\n", opIdx);
44407                 return false;
44408             }
44409         } // isDstOperand
44410
44411         void execute(GPUDynInstPtr) override;
44412     }; // Inst_VOP3__V_CMPX_LT_I64
44413
44414     class Inst_VOP3__V_CMPX_EQ_I64 : public Inst_VOP3
44415     {
44416       public:
44417         Inst_VOP3__V_CMPX_EQ_I64(InFmt_VOP3*);
44418         ~Inst_VOP3__V_CMPX_EQ_I64();
44419
44420         int
44421         getNumOperands() override
44422         {
44423             return numDstRegOperands() + numSrcRegOperands();
44424         } // getNumOperands
44425
44426         int numDstRegOperands() override { return 1; }
44427         int numSrcRegOperands() override { return 2; }
44428
44429         int
44430         getOperandSize(int opIdx) override
44431         {
44432             switch (opIdx) {
44433               case 0: //src_0
44434                 return 8;
44435               case 1: //src_1
44436                 return 8;
44437               case 2: //sdst
44438                 return 8;
44439               default:
44440                 fatal("op idx %i out of bounds\n", opIdx);
44441                 return -1;
44442             }
44443         } // getOperandSize
44444
44445         bool
44446         isSrcOperand(int opIdx) override
44447         {
44448             switch (opIdx) {
44449               case 0: //src_0
44450                 return true;
44451               case 1: //src_1
44452                 return true;
44453               case 2: //sdst
44454                 return false;
44455               default:
44456                 fatal("op idx %i out of bounds\n", opIdx);
44457                 return false;
44458             }
44459         } // isSrcOperand
44460
44461         bool
44462         isDstOperand(int opIdx) override
44463         {
44464             switch (opIdx) {
44465               case 0: //src_0
44466                 return false;
44467               case 1: //src_1
44468                 return false;
44469               case 2: //sdst
44470                 return true;
44471               default:
44472                 fatal("op idx %i out of bounds\n", opIdx);
44473                 return false;
44474             }
44475         } // isDstOperand
44476
44477         void execute(GPUDynInstPtr) override;
44478     }; // Inst_VOP3__V_CMPX_EQ_I64
44479
44480     class Inst_VOP3__V_CMPX_LE_I64 : public Inst_VOP3
44481     {
44482       public:
44483         Inst_VOP3__V_CMPX_LE_I64(InFmt_VOP3*);
44484         ~Inst_VOP3__V_CMPX_LE_I64();
44485
44486         int
44487         getNumOperands() override
44488         {
44489             return numDstRegOperands() + numSrcRegOperands();
44490         } // getNumOperands
44491
44492         int numDstRegOperands() override { return 1; }
44493         int numSrcRegOperands() override { return 2; }
44494
44495         int
44496         getOperandSize(int opIdx) override
44497         {
44498             switch (opIdx) {
44499               case 0: //src_0
44500                 return 8;
44501               case 1: //src_1
44502                 return 8;
44503               case 2: //sdst
44504                 return 8;
44505               default:
44506                 fatal("op idx %i out of bounds\n", opIdx);
44507                 return -1;
44508             }
44509         } // getOperandSize
44510
44511         bool
44512         isSrcOperand(int opIdx) override
44513         {
44514             switch (opIdx) {
44515               case 0: //src_0
44516                 return true;
44517               case 1: //src_1
44518                 return true;
44519               case 2: //sdst
44520                 return false;
44521               default:
44522                 fatal("op idx %i out of bounds\n", opIdx);
44523                 return false;
44524             }
44525         } // isSrcOperand
44526
44527         bool
44528         isDstOperand(int opIdx) override
44529         {
44530             switch (opIdx) {
44531               case 0: //src_0
44532                 return false;
44533               case 1: //src_1
44534                 return false;
44535               case 2: //sdst
44536                 return true;
44537               default:
44538                 fatal("op idx %i out of bounds\n", opIdx);
44539                 return false;
44540             }
44541         } // isDstOperand
44542
44543         void execute(GPUDynInstPtr) override;
44544     }; // Inst_VOP3__V_CMPX_LE_I64
44545
44546     class Inst_VOP3__V_CMPX_GT_I64 : public Inst_VOP3
44547     {
44548       public:
44549         Inst_VOP3__V_CMPX_GT_I64(InFmt_VOP3*);
44550         ~Inst_VOP3__V_CMPX_GT_I64();
44551
44552         int
44553         getNumOperands() override
44554         {
44555             return numDstRegOperands() + numSrcRegOperands();
44556         } // getNumOperands
44557
44558         int numDstRegOperands() override { return 1; }
44559         int numSrcRegOperands() override { return 2; }
44560
44561         int
44562         getOperandSize(int opIdx) override
44563         {
44564             switch (opIdx) {
44565               case 0: //src_0
44566                 return 8;
44567               case 1: //src_1
44568                 return 8;
44569               case 2: //sdst
44570                 return 8;
44571               default:
44572                 fatal("op idx %i out of bounds\n", opIdx);
44573                 return -1;
44574             }
44575         } // getOperandSize
44576
44577         bool
44578         isSrcOperand(int opIdx) override
44579         {
44580             switch (opIdx) {
44581               case 0: //src_0
44582                 return true;
44583               case 1: //src_1
44584                 return true;
44585               case 2: //sdst
44586                 return false;
44587               default:
44588                 fatal("op idx %i out of bounds\n", opIdx);
44589                 return false;
44590             }
44591         } // isSrcOperand
44592
44593         bool
44594         isDstOperand(int opIdx) override
44595         {
44596             switch (opIdx) {
44597               case 0: //src_0
44598                 return false;
44599               case 1: //src_1
44600                 return false;
44601               case 2: //sdst
44602                 return true;
44603               default:
44604                 fatal("op idx %i out of bounds\n", opIdx);
44605                 return false;
44606             }
44607         } // isDstOperand
44608
44609         void execute(GPUDynInstPtr) override;
44610     }; // Inst_VOP3__V_CMPX_GT_I64
44611
44612     class Inst_VOP3__V_CMPX_NE_I64 : public Inst_VOP3
44613     {
44614       public:
44615         Inst_VOP3__V_CMPX_NE_I64(InFmt_VOP3*);
44616         ~Inst_VOP3__V_CMPX_NE_I64();
44617
44618         int
44619         getNumOperands() override
44620         {
44621             return numDstRegOperands() + numSrcRegOperands();
44622         } // getNumOperands
44623
44624         int numDstRegOperands() override { return 1; }
44625         int numSrcRegOperands() override { return 2; }
44626
44627         int
44628         getOperandSize(int opIdx) override
44629         {
44630             switch (opIdx) {
44631               case 0: //src_0
44632                 return 8;
44633               case 1: //src_1
44634                 return 8;
44635               case 2: //sdst
44636                 return 8;
44637               default:
44638                 fatal("op idx %i out of bounds\n", opIdx);
44639                 return -1;
44640             }
44641         } // getOperandSize
44642
44643         bool
44644         isSrcOperand(int opIdx) override
44645         {
44646             switch (opIdx) {
44647               case 0: //src_0
44648                 return true;
44649               case 1: //src_1
44650                 return true;
44651               case 2: //sdst
44652                 return false;
44653               default:
44654                 fatal("op idx %i out of bounds\n", opIdx);
44655                 return false;
44656             }
44657         } // isSrcOperand
44658
44659         bool
44660         isDstOperand(int opIdx) override
44661         {
44662             switch (opIdx) {
44663               case 0: //src_0
44664                 return false;
44665               case 1: //src_1
44666                 return false;
44667               case 2: //sdst
44668                 return true;
44669               default:
44670                 fatal("op idx %i out of bounds\n", opIdx);
44671                 return false;
44672             }
44673         } // isDstOperand
44674
44675         void execute(GPUDynInstPtr) override;
44676     }; // Inst_VOP3__V_CMPX_NE_I64
44677
44678     class Inst_VOP3__V_CMPX_GE_I64 : public Inst_VOP3
44679     {
44680       public:
44681         Inst_VOP3__V_CMPX_GE_I64(InFmt_VOP3*);
44682         ~Inst_VOP3__V_CMPX_GE_I64();
44683
44684         int
44685         getNumOperands() override
44686         {
44687             return numDstRegOperands() + numSrcRegOperands();
44688         } // getNumOperands
44689
44690         int numDstRegOperands() override { return 1; }
44691         int numSrcRegOperands() override { return 2; }
44692
44693         int
44694         getOperandSize(int opIdx) override
44695         {
44696             switch (opIdx) {
44697               case 0: //src_0
44698                 return 8;
44699               case 1: //src_1
44700                 return 8;
44701               case 2: //sdst
44702                 return 8;
44703               default:
44704                 fatal("op idx %i out of bounds\n", opIdx);
44705                 return -1;
44706             }
44707         } // getOperandSize
44708
44709         bool
44710         isSrcOperand(int opIdx) override
44711         {
44712             switch (opIdx) {
44713               case 0: //src_0
44714                 return true;
44715               case 1: //src_1
44716                 return true;
44717               case 2: //sdst
44718                 return false;
44719               default:
44720                 fatal("op idx %i out of bounds\n", opIdx);
44721                 return false;
44722             }
44723         } // isSrcOperand
44724
44725         bool
44726         isDstOperand(int opIdx) override
44727         {
44728             switch (opIdx) {
44729               case 0: //src_0
44730                 return false;
44731               case 1: //src_1
44732                 return false;
44733               case 2: //sdst
44734                 return true;
44735               default:
44736                 fatal("op idx %i out of bounds\n", opIdx);
44737                 return false;
44738             }
44739         } // isDstOperand
44740
44741         void execute(GPUDynInstPtr) override;
44742     }; // Inst_VOP3__V_CMPX_GE_I64
44743
44744     class Inst_VOP3__V_CMPX_T_I64 : public Inst_VOP3
44745     {
44746       public:
44747         Inst_VOP3__V_CMPX_T_I64(InFmt_VOP3*);
44748         ~Inst_VOP3__V_CMPX_T_I64();
44749
44750         int
44751         getNumOperands() override
44752         {
44753             return numDstRegOperands() + numSrcRegOperands();
44754         } // getNumOperands
44755
44756         int numDstRegOperands() override { return 1; }
44757         int numSrcRegOperands() override { return 2; }
44758
44759         int
44760         getOperandSize(int opIdx) override
44761         {
44762             switch (opIdx) {
44763               case 0: //src_0
44764                 return 8;
44765               case 1: //src_1
44766                 return 8;
44767               case 2: //sdst
44768                 return 8;
44769               default:
44770                 fatal("op idx %i out of bounds\n", opIdx);
44771                 return -1;
44772             }
44773         } // getOperandSize
44774
44775         bool
44776         isSrcOperand(int opIdx) override
44777         {
44778             switch (opIdx) {
44779               case 0: //src_0
44780                 return true;
44781               case 1: //src_1
44782                 return true;
44783               case 2: //sdst
44784                 return false;
44785               default:
44786                 fatal("op idx %i out of bounds\n", opIdx);
44787                 return false;
44788             }
44789         } // isSrcOperand
44790
44791         bool
44792         isDstOperand(int opIdx) override
44793         {
44794             switch (opIdx) {
44795               case 0: //src_0
44796                 return false;
44797               case 1: //src_1
44798                 return false;
44799               case 2: //sdst
44800                 return true;
44801               default:
44802                 fatal("op idx %i out of bounds\n", opIdx);
44803                 return false;
44804             }
44805         } // isDstOperand
44806
44807         void execute(GPUDynInstPtr) override;
44808     }; // Inst_VOP3__V_CMPX_T_I64
44809
44810     class Inst_VOP3__V_CMPX_F_U64 : public Inst_VOP3
44811     {
44812       public:
44813         Inst_VOP3__V_CMPX_F_U64(InFmt_VOP3*);
44814         ~Inst_VOP3__V_CMPX_F_U64();
44815
44816         int
44817         getNumOperands() override
44818         {
44819             return numDstRegOperands() + numSrcRegOperands();
44820         } // getNumOperands
44821
44822         int numDstRegOperands() override { return 1; }
44823         int numSrcRegOperands() override { return 2; }
44824
44825         int
44826         getOperandSize(int opIdx) override
44827         {
44828             switch (opIdx) {
44829               case 0: //src_0
44830                 return 8;
44831               case 1: //src_1
44832                 return 8;
44833               case 2: //sdst
44834                 return 8;
44835               default:
44836                 fatal("op idx %i out of bounds\n", opIdx);
44837                 return -1;
44838             }
44839         } // getOperandSize
44840
44841         bool
44842         isSrcOperand(int opIdx) override
44843         {
44844             switch (opIdx) {
44845               case 0: //src_0
44846                 return true;
44847               case 1: //src_1
44848                 return true;
44849               case 2: //sdst
44850                 return false;
44851               default:
44852                 fatal("op idx %i out of bounds\n", opIdx);
44853                 return false;
44854             }
44855         } // isSrcOperand
44856
44857         bool
44858         isDstOperand(int opIdx) override
44859         {
44860             switch (opIdx) {
44861               case 0: //src_0
44862                 return false;
44863               case 1: //src_1
44864                 return false;
44865               case 2: //sdst
44866                 return true;
44867               default:
44868                 fatal("op idx %i out of bounds\n", opIdx);
44869                 return false;
44870             }
44871         } // isDstOperand
44872
44873         void execute(GPUDynInstPtr) override;
44874     }; // Inst_VOP3__V_CMPX_F_U64
44875
44876     class Inst_VOP3__V_CMPX_LT_U64 : public Inst_VOP3
44877     {
44878       public:
44879         Inst_VOP3__V_CMPX_LT_U64(InFmt_VOP3*);
44880         ~Inst_VOP3__V_CMPX_LT_U64();
44881
44882         int
44883         getNumOperands() override
44884         {
44885             return numDstRegOperands() + numSrcRegOperands();
44886         } // getNumOperands
44887
44888         int numDstRegOperands() override { return 1; }
44889         int numSrcRegOperands() override { return 2; }
44890
44891         int
44892         getOperandSize(int opIdx) override
44893         {
44894             switch (opIdx) {
44895               case 0: //src_0
44896                 return 8;
44897               case 1: //src_1
44898                 return 8;
44899               case 2: //sdst
44900                 return 8;
44901               default:
44902                 fatal("op idx %i out of bounds\n", opIdx);
44903                 return -1;
44904             }
44905         } // getOperandSize
44906
44907         bool
44908         isSrcOperand(int opIdx) override
44909         {
44910             switch (opIdx) {
44911               case 0: //src_0
44912                 return true;
44913               case 1: //src_1
44914                 return true;
44915               case 2: //sdst
44916                 return false;
44917               default:
44918                 fatal("op idx %i out of bounds\n", opIdx);
44919                 return false;
44920             }
44921         } // isSrcOperand
44922
44923         bool
44924         isDstOperand(int opIdx) override
44925         {
44926             switch (opIdx) {
44927               case 0: //src_0
44928                 return false;
44929               case 1: //src_1
44930                 return false;
44931               case 2: //sdst
44932                 return true;
44933               default:
44934                 fatal("op idx %i out of bounds\n", opIdx);
44935                 return false;
44936             }
44937         } // isDstOperand
44938
44939         void execute(GPUDynInstPtr) override;
44940     }; // Inst_VOP3__V_CMPX_LT_U64
44941
44942     class Inst_VOP3__V_CMPX_EQ_U64 : public Inst_VOP3
44943     {
44944       public:
44945         Inst_VOP3__V_CMPX_EQ_U64(InFmt_VOP3*);
44946         ~Inst_VOP3__V_CMPX_EQ_U64();
44947
44948         int
44949         getNumOperands() override
44950         {
44951             return numDstRegOperands() + numSrcRegOperands();
44952         } // getNumOperands
44953
44954         int numDstRegOperands() override { return 1; }
44955         int numSrcRegOperands() override { return 2; }
44956
44957         int
44958         getOperandSize(int opIdx) override
44959         {
44960             switch (opIdx) {
44961               case 0: //src_0
44962                 return 8;
44963               case 1: //src_1
44964                 return 8;
44965               case 2: //sdst
44966                 return 8;
44967               default:
44968                 fatal("op idx %i out of bounds\n", opIdx);
44969                 return -1;
44970             }
44971         } // getOperandSize
44972
44973         bool
44974         isSrcOperand(int opIdx) override
44975         {
44976             switch (opIdx) {
44977               case 0: //src_0
44978                 return true;
44979               case 1: //src_1
44980                 return true;
44981               case 2: //sdst
44982                 return false;
44983               default:
44984                 fatal("op idx %i out of bounds\n", opIdx);
44985                 return false;
44986             }
44987         } // isSrcOperand
44988
44989         bool
44990         isDstOperand(int opIdx) override
44991         {
44992             switch (opIdx) {
44993               case 0: //src_0
44994                 return false;
44995               case 1: //src_1
44996                 return false;
44997               case 2: //sdst
44998                 return true;
44999               default:
45000                 fatal("op idx %i out of bounds\n", opIdx);
45001                 return false;
45002             }
45003         } // isDstOperand
45004
45005         void execute(GPUDynInstPtr) override;
45006     }; // Inst_VOP3__V_CMPX_EQ_U64
45007
45008     class Inst_VOP3__V_CMPX_LE_U64 : public Inst_VOP3
45009     {
45010       public:
45011         Inst_VOP3__V_CMPX_LE_U64(InFmt_VOP3*);
45012         ~Inst_VOP3__V_CMPX_LE_U64();
45013
45014         int
45015         getNumOperands() override
45016         {
45017             return numDstRegOperands() + numSrcRegOperands();
45018         } // getNumOperands
45019
45020         int numDstRegOperands() override { return 1; }
45021         int numSrcRegOperands() override { return 2; }
45022
45023         int
45024         getOperandSize(int opIdx) override
45025         {
45026             switch (opIdx) {
45027               case 0: //src_0
45028                 return 8;
45029               case 1: //src_1
45030                 return 8;
45031               case 2: //sdst
45032                 return 8;
45033               default:
45034                 fatal("op idx %i out of bounds\n", opIdx);
45035                 return -1;
45036             }
45037         } // getOperandSize
45038
45039         bool
45040         isSrcOperand(int opIdx) override
45041         {
45042             switch (opIdx) {
45043               case 0: //src_0
45044                 return true;
45045               case 1: //src_1
45046                 return true;
45047               case 2: //sdst
45048                 return false;
45049               default:
45050                 fatal("op idx %i out of bounds\n", opIdx);
45051                 return false;
45052             }
45053         } // isSrcOperand
45054
45055         bool
45056         isDstOperand(int opIdx) override
45057         {
45058             switch (opIdx) {
45059               case 0: //src_0
45060                 return false;
45061               case 1: //src_1
45062                 return false;
45063               case 2: //sdst
45064                 return true;
45065               default:
45066                 fatal("op idx %i out of bounds\n", opIdx);
45067                 return false;
45068             }
45069         } // isDstOperand
45070
45071         void execute(GPUDynInstPtr) override;
45072     }; // Inst_VOP3__V_CMPX_LE_U64
45073
45074     class Inst_VOP3__V_CMPX_GT_U64 : public Inst_VOP3
45075     {
45076       public:
45077         Inst_VOP3__V_CMPX_GT_U64(InFmt_VOP3*);
45078         ~Inst_VOP3__V_CMPX_GT_U64();
45079
45080         int
45081         getNumOperands() override
45082         {
45083             return numDstRegOperands() + numSrcRegOperands();
45084         } // getNumOperands
45085
45086         int numDstRegOperands() override { return 1; }
45087         int numSrcRegOperands() override { return 2; }
45088
45089         int
45090         getOperandSize(int opIdx) override
45091         {
45092             switch (opIdx) {
45093               case 0: //src_0
45094                 return 8;
45095               case 1: //src_1
45096                 return 8;
45097               case 2: //sdst
45098                 return 8;
45099               default:
45100                 fatal("op idx %i out of bounds\n", opIdx);
45101                 return -1;
45102             }
45103         } // getOperandSize
45104
45105         bool
45106         isSrcOperand(int opIdx) override
45107         {
45108             switch (opIdx) {
45109               case 0: //src_0
45110                 return true;
45111               case 1: //src_1
45112                 return true;
45113               case 2: //sdst
45114                 return false;
45115               default:
45116                 fatal("op idx %i out of bounds\n", opIdx);
45117                 return false;
45118             }
45119         } // isSrcOperand
45120
45121         bool
45122         isDstOperand(int opIdx) override
45123         {
45124             switch (opIdx) {
45125               case 0: //src_0
45126                 return false;
45127               case 1: //src_1
45128                 return false;
45129               case 2: //sdst
45130                 return true;
45131               default:
45132                 fatal("op idx %i out of bounds\n", opIdx);
45133                 return false;
45134             }
45135         } // isDstOperand
45136
45137         void execute(GPUDynInstPtr) override;
45138     }; // Inst_VOP3__V_CMPX_GT_U64
45139
45140     class Inst_VOP3__V_CMPX_NE_U64 : public Inst_VOP3
45141     {
45142       public:
45143         Inst_VOP3__V_CMPX_NE_U64(InFmt_VOP3*);
45144         ~Inst_VOP3__V_CMPX_NE_U64();
45145
45146         int
45147         getNumOperands() override
45148         {
45149             return numDstRegOperands() + numSrcRegOperands();
45150         } // getNumOperands
45151
45152         int numDstRegOperands() override { return 1; }
45153         int numSrcRegOperands() override { return 2; }
45154
45155         int
45156         getOperandSize(int opIdx) override
45157         {
45158             switch (opIdx) {
45159               case 0: //src_0
45160                 return 8;
45161               case 1: //src_1
45162                 return 8;
45163               case 2: //sdst
45164                 return 8;
45165               default:
45166                 fatal("op idx %i out of bounds\n", opIdx);
45167                 return -1;
45168             }
45169         } // getOperandSize
45170
45171         bool
45172         isSrcOperand(int opIdx) override
45173         {
45174             switch (opIdx) {
45175               case 0: //src_0
45176                 return true;
45177               case 1: //src_1
45178                 return true;
45179               case 2: //sdst
45180                 return false;
45181               default:
45182                 fatal("op idx %i out of bounds\n", opIdx);
45183                 return false;
45184             }
45185         } // isSrcOperand
45186
45187         bool
45188         isDstOperand(int opIdx) override
45189         {
45190             switch (opIdx) {
45191               case 0: //src_0
45192                 return false;
45193               case 1: //src_1
45194                 return false;
45195               case 2: //sdst
45196                 return true;
45197               default:
45198                 fatal("op idx %i out of bounds\n", opIdx);
45199                 return false;
45200             }
45201         } // isDstOperand
45202
45203         void execute(GPUDynInstPtr) override;
45204     }; // Inst_VOP3__V_CMPX_NE_U64
45205
45206     class Inst_VOP3__V_CMPX_GE_U64 : public Inst_VOP3
45207     {
45208       public:
45209         Inst_VOP3__V_CMPX_GE_U64(InFmt_VOP3*);
45210         ~Inst_VOP3__V_CMPX_GE_U64();
45211
45212         int
45213         getNumOperands() override
45214         {
45215             return numDstRegOperands() + numSrcRegOperands();
45216         } // getNumOperands
45217
45218         int numDstRegOperands() override { return 1; }
45219         int numSrcRegOperands() override { return 2; }
45220
45221         int
45222         getOperandSize(int opIdx) override
45223         {
45224             switch (opIdx) {
45225               case 0: //src_0
45226                 return 8;
45227               case 1: //src_1
45228                 return 8;
45229               case 2: //sdst
45230                 return 8;
45231               default:
45232                 fatal("op idx %i out of bounds\n", opIdx);
45233                 return -1;
45234             }
45235         } // getOperandSize
45236
45237         bool
45238         isSrcOperand(int opIdx) override
45239         {
45240             switch (opIdx) {
45241               case 0: //src_0
45242                 return true;
45243               case 1: //src_1
45244                 return true;
45245               case 2: //sdst
45246                 return false;
45247               default:
45248                 fatal("op idx %i out of bounds\n", opIdx);
45249                 return false;
45250             }
45251         } // isSrcOperand
45252
45253         bool
45254         isDstOperand(int opIdx) override
45255         {
45256             switch (opIdx) {
45257               case 0: //src_0
45258                 return false;
45259               case 1: //src_1
45260                 return false;
45261               case 2: //sdst
45262                 return true;
45263               default:
45264                 fatal("op idx %i out of bounds\n", opIdx);
45265                 return false;
45266             }
45267         } // isDstOperand
45268
45269         void execute(GPUDynInstPtr) override;
45270     }; // Inst_VOP3__V_CMPX_GE_U64
45271
45272     class Inst_VOP3__V_CMPX_T_U64 : public Inst_VOP3
45273     {
45274       public:
45275         Inst_VOP3__V_CMPX_T_U64(InFmt_VOP3*);
45276         ~Inst_VOP3__V_CMPX_T_U64();
45277
45278         int
45279         getNumOperands() override
45280         {
45281             return numDstRegOperands() + numSrcRegOperands();
45282         } // getNumOperands
45283
45284         int numDstRegOperands() override { return 1; }
45285         int numSrcRegOperands() override { return 2; }
45286
45287         int
45288         getOperandSize(int opIdx) override
45289         {
45290             switch (opIdx) {
45291               case 0: //src_0
45292                 return 8;
45293               case 1: //src_1
45294                 return 8;
45295               case 2: //sdst
45296                 return 8;
45297               default:
45298                 fatal("op idx %i out of bounds\n", opIdx);
45299                 return -1;
45300             }
45301         } // getOperandSize
45302
45303         bool
45304         isSrcOperand(int opIdx) override
45305         {
45306             switch (opIdx) {
45307               case 0: //src_0
45308                 return true;
45309               case 1: //src_1
45310                 return true;
45311               case 2: //sdst
45312                 return false;
45313               default:
45314                 fatal("op idx %i out of bounds\n", opIdx);
45315                 return false;
45316             }
45317         } // isSrcOperand
45318
45319         bool
45320         isDstOperand(int opIdx) override
45321         {
45322             switch (opIdx) {
45323               case 0: //src_0
45324                 return false;
45325               case 1: //src_1
45326                 return false;
45327               case 2: //sdst
45328                 return true;
45329               default:
45330                 fatal("op idx %i out of bounds\n", opIdx);
45331                 return false;
45332             }
45333         } // isDstOperand
45334
45335         void execute(GPUDynInstPtr) override;
45336     }; // Inst_VOP3__V_CMPX_T_U64
45337
45338     class Inst_VOP3__V_CNDMASK_B32 : public Inst_VOP3
45339     {
45340       public:
45341         Inst_VOP3__V_CNDMASK_B32(InFmt_VOP3*);
45342         ~Inst_VOP3__V_CNDMASK_B32();
45343
45344         int
45345         getNumOperands() override
45346         {
45347             return numDstRegOperands() + numSrcRegOperands();
45348         } // getNumOperands
45349
45350         int numDstRegOperands() override { return 1; }
45351         int numSrcRegOperands() override { return 3; }
45352
45353         int
45354         getOperandSize(int opIdx) override
45355         {
45356             switch (opIdx) {
45357               case 0: //src_0
45358                 return 4;
45359               case 1: //src_1
45360                 return 4;
45361               case 2: //carryin
45362                 return 8;
45363               case 3: //vdst
45364                 return 4;
45365               default:
45366                 fatal("op idx %i out of bounds\n", opIdx);
45367                 return -1;
45368             }
45369         } // getOperandSize
45370
45371         bool
45372         isSrcOperand(int opIdx) override
45373         {
45374             switch (opIdx) {
45375               case 0: //src_0
45376                 return true;
45377               case 1: //src_1
45378                 return true;
45379               case 2: //carryin
45380                 return true;
45381               case 3: //vdst
45382                 return false;
45383               default:
45384                 fatal("op idx %i out of bounds\n", opIdx);
45385                 return false;
45386             }
45387         } // isSrcOperand
45388
45389         bool
45390         isDstOperand(int opIdx) override
45391         {
45392             switch (opIdx) {
45393               case 0: //src_0
45394                 return false;
45395               case 1: //src_1
45396                 return false;
45397               case 2: //carryin
45398                 return false;
45399               case 3: //vdst
45400                 return true;
45401               default:
45402                 fatal("op idx %i out of bounds\n", opIdx);
45403                 return false;
45404             }
45405         } // isDstOperand
45406
45407         void execute(GPUDynInstPtr) override;
45408     }; // Inst_VOP3__V_CNDMASK_B32
45409
45410     class Inst_VOP3__V_ADD_F32 : public Inst_VOP3
45411     {
45412       public:
45413         Inst_VOP3__V_ADD_F32(InFmt_VOP3*);
45414         ~Inst_VOP3__V_ADD_F32();
45415
45416         int
45417         getNumOperands() override
45418         {
45419             return numDstRegOperands() + numSrcRegOperands();
45420         } // getNumOperands
45421
45422         int numDstRegOperands() override { return 1; }
45423         int numSrcRegOperands() override { return 2; }
45424
45425         int
45426         getOperandSize(int opIdx) override
45427         {
45428             switch (opIdx) {
45429               case 0: //src_0
45430                 return 4;
45431               case 1: //src_1
45432                 return 4;
45433               case 2: //vdst
45434                 return 4;
45435               default:
45436                 fatal("op idx %i out of bounds\n", opIdx);
45437                 return -1;
45438             }
45439         } // getOperandSize
45440
45441         bool
45442         isSrcOperand(int opIdx) override
45443         {
45444             switch (opIdx) {
45445               case 0: //src_0
45446                 return true;
45447               case 1: //src_1
45448                 return true;
45449               case 2: //vdst
45450                 return false;
45451               default:
45452                 fatal("op idx %i out of bounds\n", opIdx);
45453                 return false;
45454             }
45455         } // isSrcOperand
45456
45457         bool
45458         isDstOperand(int opIdx) override
45459         {
45460             switch (opIdx) {
45461               case 0: //src_0
45462                 return false;
45463               case 1: //src_1
45464                 return false;
45465               case 2: //vdst
45466                 return true;
45467               default:
45468                 fatal("op idx %i out of bounds\n", opIdx);
45469                 return false;
45470             }
45471         } // isDstOperand
45472
45473         void execute(GPUDynInstPtr) override;
45474     }; // Inst_VOP3__V_ADD_F32
45475
45476     class Inst_VOP3__V_SUB_F32 : public Inst_VOP3
45477     {
45478       public:
45479         Inst_VOP3__V_SUB_F32(InFmt_VOP3*);
45480         ~Inst_VOP3__V_SUB_F32();
45481
45482         int
45483         getNumOperands() override
45484         {
45485             return numDstRegOperands() + numSrcRegOperands();
45486         } // getNumOperands
45487
45488         int numDstRegOperands() override { return 1; }
45489         int numSrcRegOperands() override { return 2; }
45490
45491         int
45492         getOperandSize(int opIdx) override
45493         {
45494             switch (opIdx) {
45495               case 0: //src_0
45496                 return 4;
45497               case 1: //src_1
45498                 return 4;
45499               case 2: //vdst
45500                 return 4;
45501               default:
45502                 fatal("op idx %i out of bounds\n", opIdx);
45503                 return -1;
45504             }
45505         } // getOperandSize
45506
45507         bool
45508         isSrcOperand(int opIdx) override
45509         {
45510             switch (opIdx) {
45511               case 0: //src_0
45512                 return true;
45513               case 1: //src_1
45514                 return true;
45515               case 2: //vdst
45516                 return false;
45517               default:
45518                 fatal("op idx %i out of bounds\n", opIdx);
45519                 return false;
45520             }
45521         } // isSrcOperand
45522
45523         bool
45524         isDstOperand(int opIdx) override
45525         {
45526             switch (opIdx) {
45527               case 0: //src_0
45528                 return false;
45529               case 1: //src_1
45530                 return false;
45531               case 2: //vdst
45532                 return true;
45533               default:
45534                 fatal("op idx %i out of bounds\n", opIdx);
45535                 return false;
45536             }
45537         } // isDstOperand
45538
45539         void execute(GPUDynInstPtr) override;
45540     }; // Inst_VOP3__V_SUB_F32
45541
45542     class Inst_VOP3__V_SUBREV_F32 : public Inst_VOP3
45543     {
45544       public:
45545         Inst_VOP3__V_SUBREV_F32(InFmt_VOP3*);
45546         ~Inst_VOP3__V_SUBREV_F32();
45547
45548         int
45549         getNumOperands() override
45550         {
45551             return numDstRegOperands() + numSrcRegOperands();
45552         } // getNumOperands
45553
45554         int numDstRegOperands() override { return 1; }
45555         int numSrcRegOperands() override { return 2; }
45556
45557         int
45558         getOperandSize(int opIdx) override
45559         {
45560             switch (opIdx) {
45561               case 0: //src_0
45562                 return 4;
45563               case 1: //src_1
45564                 return 4;
45565               case 2: //vdst
45566                 return 4;
45567               default:
45568                 fatal("op idx %i out of bounds\n", opIdx);
45569                 return -1;
45570             }
45571         } // getOperandSize
45572
45573         bool
45574         isSrcOperand(int opIdx) override
45575         {
45576             switch (opIdx) {
45577               case 0: //src_0
45578                 return true;
45579               case 1: //src_1
45580                 return true;
45581               case 2: //vdst
45582                 return false;
45583               default:
45584                 fatal("op idx %i out of bounds\n", opIdx);
45585                 return false;
45586             }
45587         } // isSrcOperand
45588
45589         bool
45590         isDstOperand(int opIdx) override
45591         {
45592             switch (opIdx) {
45593               case 0: //src_0
45594                 return false;
45595               case 1: //src_1
45596                 return false;
45597               case 2: //vdst
45598                 return true;
45599               default:
45600                 fatal("op idx %i out of bounds\n", opIdx);
45601                 return false;
45602             }
45603         } // isDstOperand
45604
45605         void execute(GPUDynInstPtr) override;
45606     }; // Inst_VOP3__V_SUBREV_F32
45607
45608     class Inst_VOP3__V_MUL_LEGACY_F32 : public Inst_VOP3
45609     {
45610       public:
45611         Inst_VOP3__V_MUL_LEGACY_F32(InFmt_VOP3*);
45612         ~Inst_VOP3__V_MUL_LEGACY_F32();
45613
45614         int
45615         getNumOperands() override
45616         {
45617             return numDstRegOperands() + numSrcRegOperands();
45618         } // getNumOperands
45619
45620         int numDstRegOperands() override { return 1; }
45621         int numSrcRegOperands() override { return 2; }
45622
45623         int
45624         getOperandSize(int opIdx) override
45625         {
45626             switch (opIdx) {
45627               case 0: //src_0
45628                 return 4;
45629               case 1: //src_1
45630                 return 4;
45631               case 2: //vdst
45632                 return 4;
45633               default:
45634                 fatal("op idx %i out of bounds\n", opIdx);
45635                 return -1;
45636             }
45637         } // getOperandSize
45638
45639         bool
45640         isSrcOperand(int opIdx) override
45641         {
45642             switch (opIdx) {
45643               case 0: //src_0
45644                 return true;
45645               case 1: //src_1
45646                 return true;
45647               case 2: //vdst
45648                 return false;
45649               default:
45650                 fatal("op idx %i out of bounds\n", opIdx);
45651                 return false;
45652             }
45653         } // isSrcOperand
45654
45655         bool
45656         isDstOperand(int opIdx) override
45657         {
45658             switch (opIdx) {
45659               case 0: //src_0
45660                 return false;
45661               case 1: //src_1
45662                 return false;
45663               case 2: //vdst
45664                 return true;
45665               default:
45666                 fatal("op idx %i out of bounds\n", opIdx);
45667                 return false;
45668             }
45669         } // isDstOperand
45670
45671         void execute(GPUDynInstPtr) override;
45672     }; // Inst_VOP3__V_MUL_LEGACY_F32
45673
45674     class Inst_VOP3__V_MUL_F32 : public Inst_VOP3
45675     {
45676       public:
45677         Inst_VOP3__V_MUL_F32(InFmt_VOP3*);
45678         ~Inst_VOP3__V_MUL_F32();
45679
45680         int
45681         getNumOperands() override
45682         {
45683             return numDstRegOperands() + numSrcRegOperands();
45684         } // getNumOperands
45685
45686         int numDstRegOperands() override { return 1; }
45687         int numSrcRegOperands() override { return 2; }
45688
45689         int
45690         getOperandSize(int opIdx) override
45691         {
45692             switch (opIdx) {
45693               case 0: //src_0
45694                 return 4;
45695               case 1: //src_1
45696                 return 4;
45697               case 2: //vdst
45698                 return 4;
45699               default:
45700                 fatal("op idx %i out of bounds\n", opIdx);
45701                 return -1;
45702             }
45703         } // getOperandSize
45704
45705         bool
45706         isSrcOperand(int opIdx) override
45707         {
45708             switch (opIdx) {
45709               case 0: //src_0
45710                 return true;
45711               case 1: //src_1
45712                 return true;
45713               case 2: //vdst
45714                 return false;
45715               default:
45716                 fatal("op idx %i out of bounds\n", opIdx);
45717                 return false;
45718             }
45719         } // isSrcOperand
45720
45721         bool
45722         isDstOperand(int opIdx) override
45723         {
45724             switch (opIdx) {
45725               case 0: //src_0
45726                 return false;
45727               case 1: //src_1
45728                 return false;
45729               case 2: //vdst
45730                 return true;
45731               default:
45732                 fatal("op idx %i out of bounds\n", opIdx);
45733                 return false;
45734             }
45735         } // isDstOperand
45736
45737         void execute(GPUDynInstPtr) override;
45738     }; // Inst_VOP3__V_MUL_F32
45739
45740     class Inst_VOP3__V_MUL_I32_I24 : public Inst_VOP3
45741     {
45742       public:
45743         Inst_VOP3__V_MUL_I32_I24(InFmt_VOP3*);
45744         ~Inst_VOP3__V_MUL_I32_I24();
45745
45746         int
45747         getNumOperands() override
45748         {
45749             return numDstRegOperands() + numSrcRegOperands();
45750         } // getNumOperands
45751
45752         int numDstRegOperands() override { return 1; }
45753         int numSrcRegOperands() override { return 2; }
45754
45755         int
45756         getOperandSize(int opIdx) override
45757         {
45758             switch (opIdx) {
45759               case 0: //src_0
45760                 return 4;
45761               case 1: //src_1
45762                 return 4;
45763               case 2: //vdst
45764                 return 4;
45765               default:
45766                 fatal("op idx %i out of bounds\n", opIdx);
45767                 return -1;
45768             }
45769         } // getOperandSize
45770
45771         bool
45772         isSrcOperand(int opIdx) override
45773         {
45774             switch (opIdx) {
45775               case 0: //src_0
45776                 return true;
45777               case 1: //src_1
45778                 return true;
45779               case 2: //vdst
45780                 return false;
45781               default:
45782                 fatal("op idx %i out of bounds\n", opIdx);
45783                 return false;
45784             }
45785         } // isSrcOperand
45786
45787         bool
45788         isDstOperand(int opIdx) override
45789         {
45790             switch (opIdx) {
45791               case 0: //src_0
45792                 return false;
45793               case 1: //src_1
45794                 return false;
45795               case 2: //vdst
45796                 return true;
45797               default:
45798                 fatal("op idx %i out of bounds\n", opIdx);
45799                 return false;
45800             }
45801         } // isDstOperand
45802
45803         void execute(GPUDynInstPtr) override;
45804     }; // Inst_VOP3__V_MUL_I32_I24
45805
45806     class Inst_VOP3__V_MUL_HI_I32_I24 : public Inst_VOP3
45807     {
45808       public:
45809         Inst_VOP3__V_MUL_HI_I32_I24(InFmt_VOP3*);
45810         ~Inst_VOP3__V_MUL_HI_I32_I24();
45811
45812         int
45813         getNumOperands() override
45814         {
45815             return numDstRegOperands() + numSrcRegOperands();
45816         } // getNumOperands
45817
45818         int numDstRegOperands() override { return 1; }
45819         int numSrcRegOperands() override { return 2; }
45820
45821         int
45822         getOperandSize(int opIdx) override
45823         {
45824             switch (opIdx) {
45825               case 0: //src_0
45826                 return 4;
45827               case 1: //src_1
45828                 return 4;
45829               case 2: //vdst
45830                 return 4;
45831               default:
45832                 fatal("op idx %i out of bounds\n", opIdx);
45833                 return -1;
45834             }
45835         } // getOperandSize
45836
45837         bool
45838         isSrcOperand(int opIdx) override
45839         {
45840             switch (opIdx) {
45841               case 0: //src_0
45842                 return true;
45843               case 1: //src_1
45844                 return true;
45845               case 2: //vdst
45846                 return false;
45847               default:
45848                 fatal("op idx %i out of bounds\n", opIdx);
45849                 return false;
45850             }
45851         } // isSrcOperand
45852
45853         bool
45854         isDstOperand(int opIdx) override
45855         {
45856             switch (opIdx) {
45857               case 0: //src_0
45858                 return false;
45859               case 1: //src_1
45860                 return false;
45861               case 2: //vdst
45862                 return true;
45863               default:
45864                 fatal("op idx %i out of bounds\n", opIdx);
45865                 return false;
45866             }
45867         } // isDstOperand
45868
45869         void execute(GPUDynInstPtr) override;
45870     }; // Inst_VOP3__V_MUL_HI_I32_I24
45871
45872     class Inst_VOP3__V_MUL_U32_U24 : public Inst_VOP3
45873     {
45874       public:
45875         Inst_VOP3__V_MUL_U32_U24(InFmt_VOP3*);
45876         ~Inst_VOP3__V_MUL_U32_U24();
45877
45878         int
45879         getNumOperands() override
45880         {
45881             return numDstRegOperands() + numSrcRegOperands();
45882         } // getNumOperands
45883
45884         int numDstRegOperands() override { return 1; }
45885         int numSrcRegOperands() override { return 2; }
45886
45887         int
45888         getOperandSize(int opIdx) override
45889         {
45890             switch (opIdx) {
45891               case 0: //src_0
45892                 return 4;
45893               case 1: //src_1
45894                 return 4;
45895               case 2: //vdst
45896                 return 4;
45897               default:
45898                 fatal("op idx %i out of bounds\n", opIdx);
45899                 return -1;
45900             }
45901         } // getOperandSize
45902
45903         bool
45904         isSrcOperand(int opIdx) override
45905         {
45906             switch (opIdx) {
45907               case 0: //src_0
45908                 return true;
45909               case 1: //src_1
45910                 return true;
45911               case 2: //vdst
45912                 return false;
45913               default:
45914                 fatal("op idx %i out of bounds\n", opIdx);
45915                 return false;
45916             }
45917         } // isSrcOperand
45918
45919         bool
45920         isDstOperand(int opIdx) override
45921         {
45922             switch (opIdx) {
45923               case 0: //src_0
45924                 return false;
45925               case 1: //src_1
45926                 return false;
45927               case 2: //vdst
45928                 return true;
45929               default:
45930                 fatal("op idx %i out of bounds\n", opIdx);
45931                 return false;
45932             }
45933         } // isDstOperand
45934
45935         void execute(GPUDynInstPtr) override;
45936     }; // Inst_VOP3__V_MUL_U32_U24
45937
45938     class Inst_VOP3__V_MUL_HI_U32_U24 : public Inst_VOP3
45939     {
45940       public:
45941         Inst_VOP3__V_MUL_HI_U32_U24(InFmt_VOP3*);
45942         ~Inst_VOP3__V_MUL_HI_U32_U24();
45943
45944         int
45945         getNumOperands() override
45946         {
45947             return numDstRegOperands() + numSrcRegOperands();
45948         } // getNumOperands
45949
45950         int numDstRegOperands() override { return 1; }
45951         int numSrcRegOperands() override { return 2; }
45952
45953         int
45954         getOperandSize(int opIdx) override
45955         {
45956             switch (opIdx) {
45957               case 0: //src_0
45958                 return 4;
45959               case 1: //src_1
45960                 return 4;
45961               case 2: //vdst
45962                 return 4;
45963               default:
45964                 fatal("op idx %i out of bounds\n", opIdx);
45965                 return -1;
45966             }
45967         } // getOperandSize
45968
45969         bool
45970         isSrcOperand(int opIdx) override
45971         {
45972             switch (opIdx) {
45973               case 0: //src_0
45974                 return true;
45975               case 1: //src_1
45976                 return true;
45977               case 2: //vdst
45978                 return false;
45979               default:
45980                 fatal("op idx %i out of bounds\n", opIdx);
45981                 return false;
45982             }
45983         } // isSrcOperand
45984
45985         bool
45986         isDstOperand(int opIdx) override
45987         {
45988             switch (opIdx) {
45989               case 0: //src_0
45990                 return false;
45991               case 1: //src_1
45992                 return false;
45993               case 2: //vdst
45994                 return true;
45995               default:
45996                 fatal("op idx %i out of bounds\n", opIdx);
45997                 return false;
45998             }
45999         } // isDstOperand
46000
46001         void execute(GPUDynInstPtr) override;
46002     }; // Inst_VOP3__V_MUL_HI_U32_U24
46003
46004     class Inst_VOP3__V_MIN_F32 : public Inst_VOP3
46005     {
46006       public:
46007         Inst_VOP3__V_MIN_F32(InFmt_VOP3*);
46008         ~Inst_VOP3__V_MIN_F32();
46009
46010         int
46011         getNumOperands() override
46012         {
46013             return numDstRegOperands() + numSrcRegOperands();
46014         } // getNumOperands
46015
46016         int numDstRegOperands() override { return 1; }
46017         int numSrcRegOperands() override { return 2; }
46018
46019         int
46020         getOperandSize(int opIdx) override
46021         {
46022             switch (opIdx) {
46023               case 0: //src_0
46024                 return 4;
46025               case 1: //src_1
46026                 return 4;
46027               case 2: //vdst
46028                 return 4;
46029               default:
46030                 fatal("op idx %i out of bounds\n", opIdx);
46031                 return -1;
46032             }
46033         } // getOperandSize
46034
46035         bool
46036         isSrcOperand(int opIdx) override
46037         {
46038             switch (opIdx) {
46039               case 0: //src_0
46040                 return true;
46041               case 1: //src_1
46042                 return true;
46043               case 2: //vdst
46044                 return false;
46045               default:
46046                 fatal("op idx %i out of bounds\n", opIdx);
46047                 return false;
46048             }
46049         } // isSrcOperand
46050
46051         bool
46052         isDstOperand(int opIdx) override
46053         {
46054             switch (opIdx) {
46055               case 0: //src_0
46056                 return false;
46057               case 1: //src_1
46058                 return false;
46059               case 2: //vdst
46060                 return true;
46061               default:
46062                 fatal("op idx %i out of bounds\n", opIdx);
46063                 return false;
46064             }
46065         } // isDstOperand
46066
46067         void execute(GPUDynInstPtr) override;
46068     }; // Inst_VOP3__V_MIN_F32
46069
46070     class Inst_VOP3__V_MAX_F32 : public Inst_VOP3
46071     {
46072       public:
46073         Inst_VOP3__V_MAX_F32(InFmt_VOP3*);
46074         ~Inst_VOP3__V_MAX_F32();
46075
46076         int
46077         getNumOperands() override
46078         {
46079             return numDstRegOperands() + numSrcRegOperands();
46080         } // getNumOperands
46081
46082         int numDstRegOperands() override { return 1; }
46083         int numSrcRegOperands() override { return 2; }
46084
46085         int
46086         getOperandSize(int opIdx) override
46087         {
46088             switch (opIdx) {
46089               case 0: //src_0
46090                 return 4;
46091               case 1: //src_1
46092                 return 4;
46093               case 2: //vdst
46094                 return 4;
46095               default:
46096                 fatal("op idx %i out of bounds\n", opIdx);
46097                 return -1;
46098             }
46099         } // getOperandSize
46100
46101         bool
46102         isSrcOperand(int opIdx) override
46103         {
46104             switch (opIdx) {
46105               case 0: //src_0
46106                 return true;
46107               case 1: //src_1
46108                 return true;
46109               case 2: //vdst
46110                 return false;
46111               default:
46112                 fatal("op idx %i out of bounds\n", opIdx);
46113                 return false;
46114             }
46115         } // isSrcOperand
46116
46117         bool
46118         isDstOperand(int opIdx) override
46119         {
46120             switch (opIdx) {
46121               case 0: //src_0
46122                 return false;
46123               case 1: //src_1
46124                 return false;
46125               case 2: //vdst
46126                 return true;
46127               default:
46128                 fatal("op idx %i out of bounds\n", opIdx);
46129                 return false;
46130             }
46131         } // isDstOperand
46132
46133         void execute(GPUDynInstPtr) override;
46134     }; // Inst_VOP3__V_MAX_F32
46135
46136     class Inst_VOP3__V_MIN_I32 : public Inst_VOP3
46137     {
46138       public:
46139         Inst_VOP3__V_MIN_I32(InFmt_VOP3*);
46140         ~Inst_VOP3__V_MIN_I32();
46141
46142         int
46143         getNumOperands() override
46144         {
46145             return numDstRegOperands() + numSrcRegOperands();
46146         } // getNumOperands
46147
46148         int numDstRegOperands() override { return 1; }
46149         int numSrcRegOperands() override { return 2; }
46150
46151         int
46152         getOperandSize(int opIdx) override
46153         {
46154             switch (opIdx) {
46155               case 0: //src_0
46156                 return 4;
46157               case 1: //src_1
46158                 return 4;
46159               case 2: //vdst
46160                 return 4;
46161               default:
46162                 fatal("op idx %i out of bounds\n", opIdx);
46163                 return -1;
46164             }
46165         } // getOperandSize
46166
46167         bool
46168         isSrcOperand(int opIdx) override
46169         {
46170             switch (opIdx) {
46171               case 0: //src_0
46172                 return true;
46173               case 1: //src_1
46174                 return true;
46175               case 2: //vdst
46176                 return false;
46177               default:
46178                 fatal("op idx %i out of bounds\n", opIdx);
46179                 return false;
46180             }
46181         } // isSrcOperand
46182
46183         bool
46184         isDstOperand(int opIdx) override
46185         {
46186             switch (opIdx) {
46187               case 0: //src_0
46188                 return false;
46189               case 1: //src_1
46190                 return false;
46191               case 2: //vdst
46192                 return true;
46193               default:
46194                 fatal("op idx %i out of bounds\n", opIdx);
46195                 return false;
46196             }
46197         } // isDstOperand
46198
46199         void execute(GPUDynInstPtr) override;
46200     }; // Inst_VOP3__V_MIN_I32
46201
46202     class Inst_VOP3__V_MAX_I32 : public Inst_VOP3
46203     {
46204       public:
46205         Inst_VOP3__V_MAX_I32(InFmt_VOP3*);
46206         ~Inst_VOP3__V_MAX_I32();
46207
46208         int
46209         getNumOperands() override
46210         {
46211             return numDstRegOperands() + numSrcRegOperands();
46212         } // getNumOperands
46213
46214         int numDstRegOperands() override { return 1; }
46215         int numSrcRegOperands() override { return 2; }
46216
46217         int
46218         getOperandSize(int opIdx) override
46219         {
46220             switch (opIdx) {
46221               case 0: //src_0
46222                 return 4;
46223               case 1: //src_1
46224                 return 4;
46225               case 2: //vdst
46226                 return 4;
46227               default:
46228                 fatal("op idx %i out of bounds\n", opIdx);
46229                 return -1;
46230             }
46231         } // getOperandSize
46232
46233         bool
46234         isSrcOperand(int opIdx) override
46235         {
46236             switch (opIdx) {
46237               case 0: //src_0
46238                 return true;
46239               case 1: //src_1
46240                 return true;
46241               case 2: //vdst
46242                 return false;
46243               default:
46244                 fatal("op idx %i out of bounds\n", opIdx);
46245                 return false;
46246             }
46247         } // isSrcOperand
46248
46249         bool
46250         isDstOperand(int opIdx) override
46251         {
46252             switch (opIdx) {
46253               case 0: //src_0
46254                 return false;
46255               case 1: //src_1
46256                 return false;
46257               case 2: //vdst
46258                 return true;
46259               default:
46260                 fatal("op idx %i out of bounds\n", opIdx);
46261                 return false;
46262             }
46263         } // isDstOperand
46264
46265         void execute(GPUDynInstPtr) override;
46266     }; // Inst_VOP3__V_MAX_I32
46267
46268     class Inst_VOP3__V_MIN_U32 : public Inst_VOP3
46269     {
46270       public:
46271         Inst_VOP3__V_MIN_U32(InFmt_VOP3*);
46272         ~Inst_VOP3__V_MIN_U32();
46273
46274         int
46275         getNumOperands() override
46276         {
46277             return numDstRegOperands() + numSrcRegOperands();
46278         } // getNumOperands
46279
46280         int numDstRegOperands() override { return 1; }
46281         int numSrcRegOperands() override { return 2; }
46282
46283         int
46284         getOperandSize(int opIdx) override
46285         {
46286             switch (opIdx) {
46287               case 0: //src_0
46288                 return 4;
46289               case 1: //src_1
46290                 return 4;
46291               case 2: //vdst
46292                 return 4;
46293               default:
46294                 fatal("op idx %i out of bounds\n", opIdx);
46295                 return -1;
46296             }
46297         } // getOperandSize
46298
46299         bool
46300         isSrcOperand(int opIdx) override
46301         {
46302             switch (opIdx) {
46303               case 0: //src_0
46304                 return true;
46305               case 1: //src_1
46306                 return true;
46307               case 2: //vdst
46308                 return false;
46309               default:
46310                 fatal("op idx %i out of bounds\n", opIdx);
46311                 return false;
46312             }
46313         } // isSrcOperand
46314
46315         bool
46316         isDstOperand(int opIdx) override
46317         {
46318             switch (opIdx) {
46319               case 0: //src_0
46320                 return false;
46321               case 1: //src_1
46322                 return false;
46323               case 2: //vdst
46324                 return true;
46325               default:
46326                 fatal("op idx %i out of bounds\n", opIdx);
46327                 return false;
46328             }
46329         } // isDstOperand
46330
46331         void execute(GPUDynInstPtr) override;
46332     }; // Inst_VOP3__V_MIN_U32
46333
46334     class Inst_VOP3__V_MAX_U32 : public Inst_VOP3
46335     {
46336       public:
46337         Inst_VOP3__V_MAX_U32(InFmt_VOP3*);
46338         ~Inst_VOP3__V_MAX_U32();
46339
46340         int
46341         getNumOperands() override
46342         {
46343             return numDstRegOperands() + numSrcRegOperands();
46344         } // getNumOperands
46345
46346         int numDstRegOperands() override { return 1; }
46347         int numSrcRegOperands() override { return 2; }
46348
46349         int
46350         getOperandSize(int opIdx) override
46351         {
46352             switch (opIdx) {
46353               case 0: //src_0
46354                 return 4;
46355               case 1: //src_1
46356                 return 4;
46357               case 2: //vdst
46358                 return 4;
46359               default:
46360                 fatal("op idx %i out of bounds\n", opIdx);
46361                 return -1;
46362             }
46363         } // getOperandSize
46364
46365         bool
46366         isSrcOperand(int opIdx) override
46367         {
46368             switch (opIdx) {
46369               case 0: //src_0
46370                 return true;
46371               case 1: //src_1
46372                 return true;
46373               case 2: //vdst
46374                 return false;
46375               default:
46376                 fatal("op idx %i out of bounds\n", opIdx);
46377                 return false;
46378             }
46379         } // isSrcOperand
46380
46381         bool
46382         isDstOperand(int opIdx) override
46383         {
46384             switch (opIdx) {
46385               case 0: //src_0
46386                 return false;
46387               case 1: //src_1
46388                 return false;
46389               case 2: //vdst
46390                 return true;
46391               default:
46392                 fatal("op idx %i out of bounds\n", opIdx);
46393                 return false;
46394             }
46395         } // isDstOperand
46396
46397         void execute(GPUDynInstPtr) override;
46398     }; // Inst_VOP3__V_MAX_U32
46399
46400     class Inst_VOP3__V_LSHRREV_B32 : public Inst_VOP3
46401     {
46402       public:
46403         Inst_VOP3__V_LSHRREV_B32(InFmt_VOP3*);
46404         ~Inst_VOP3__V_LSHRREV_B32();
46405
46406         int
46407         getNumOperands() override
46408         {
46409             return numDstRegOperands() + numSrcRegOperands();
46410         } // getNumOperands
46411
46412         int numDstRegOperands() override { return 1; }
46413         int numSrcRegOperands() override { return 2; }
46414
46415         int
46416         getOperandSize(int opIdx) override
46417         {
46418             switch (opIdx) {
46419               case 0: //src_0
46420                 return 4;
46421               case 1: //src_1
46422                 return 4;
46423               case 2: //vdst
46424                 return 4;
46425               default:
46426                 fatal("op idx %i out of bounds\n", opIdx);
46427                 return -1;
46428             }
46429         } // getOperandSize
46430
46431         bool
46432         isSrcOperand(int opIdx) override
46433         {
46434             switch (opIdx) {
46435               case 0: //src_0
46436                 return true;
46437               case 1: //src_1
46438                 return true;
46439               case 2: //vdst
46440                 return false;
46441               default:
46442                 fatal("op idx %i out of bounds\n", opIdx);
46443                 return false;
46444             }
46445         } // isSrcOperand
46446
46447         bool
46448         isDstOperand(int opIdx) override
46449         {
46450             switch (opIdx) {
46451               case 0: //src_0
46452                 return false;
46453               case 1: //src_1
46454                 return false;
46455               case 2: //vdst
46456                 return true;
46457               default:
46458                 fatal("op idx %i out of bounds\n", opIdx);
46459                 return false;
46460             }
46461         } // isDstOperand
46462
46463         void execute(GPUDynInstPtr) override;
46464     }; // Inst_VOP3__V_LSHRREV_B32
46465
46466     class Inst_VOP3__V_ASHRREV_I32 : public Inst_VOP3
46467     {
46468       public:
46469         Inst_VOP3__V_ASHRREV_I32(InFmt_VOP3*);
46470         ~Inst_VOP3__V_ASHRREV_I32();
46471
46472         int
46473         getNumOperands() override
46474         {
46475             return numDstRegOperands() + numSrcRegOperands();
46476         } // getNumOperands
46477
46478         int numDstRegOperands() override { return 1; }
46479         int numSrcRegOperands() override { return 2; }
46480
46481         int
46482         getOperandSize(int opIdx) override
46483         {
46484             switch (opIdx) {
46485               case 0: //src_0
46486                 return 4;
46487               case 1: //src_1
46488                 return 4;
46489               case 2: //vdst
46490                 return 4;
46491               default:
46492                 fatal("op idx %i out of bounds\n", opIdx);
46493                 return -1;
46494             }
46495         } // getOperandSize
46496
46497         bool
46498         isSrcOperand(int opIdx) override
46499         {
46500             switch (opIdx) {
46501               case 0: //src_0
46502                 return true;
46503               case 1: //src_1
46504                 return true;
46505               case 2: //vdst
46506                 return false;
46507               default:
46508                 fatal("op idx %i out of bounds\n", opIdx);
46509                 return false;
46510             }
46511         } // isSrcOperand
46512
46513         bool
46514         isDstOperand(int opIdx) override
46515         {
46516             switch (opIdx) {
46517               case 0: //src_0
46518                 return false;
46519               case 1: //src_1
46520                 return false;
46521               case 2: //vdst
46522                 return true;
46523               default:
46524                 fatal("op idx %i out of bounds\n", opIdx);
46525                 return false;
46526             }
46527         } // isDstOperand
46528
46529         void execute(GPUDynInstPtr) override;
46530     }; // Inst_VOP3__V_ASHRREV_I32
46531
46532     class Inst_VOP3__V_LSHLREV_B32 : public Inst_VOP3
46533     {
46534       public:
46535         Inst_VOP3__V_LSHLREV_B32(InFmt_VOP3*);
46536         ~Inst_VOP3__V_LSHLREV_B32();
46537
46538         int
46539         getNumOperands() override
46540         {
46541             return numDstRegOperands() + numSrcRegOperands();
46542         } // getNumOperands
46543
46544         int numDstRegOperands() override { return 1; }
46545         int numSrcRegOperands() override { return 2; }
46546
46547         int
46548         getOperandSize(int opIdx) override
46549         {
46550             switch (opIdx) {
46551               case 0: //src_0
46552                 return 4;
46553               case 1: //src_1
46554                 return 4;
46555               case 2: //vdst
46556                 return 4;
46557               default:
46558                 fatal("op idx %i out of bounds\n", opIdx);
46559                 return -1;
46560             }
46561         } // getOperandSize
46562
46563         bool
46564         isSrcOperand(int opIdx) override
46565         {
46566             switch (opIdx) {
46567               case 0: //src_0
46568                 return true;
46569               case 1: //src_1
46570                 return true;
46571               case 2: //vdst
46572                 return false;
46573               default:
46574                 fatal("op idx %i out of bounds\n", opIdx);
46575                 return false;
46576             }
46577         } // isSrcOperand
46578
46579         bool
46580         isDstOperand(int opIdx) override
46581         {
46582             switch (opIdx) {
46583               case 0: //src_0
46584                 return false;
46585               case 1: //src_1
46586                 return false;
46587               case 2: //vdst
46588                 return true;
46589               default:
46590                 fatal("op idx %i out of bounds\n", opIdx);
46591                 return false;
46592             }
46593         } // isDstOperand
46594
46595         void execute(GPUDynInstPtr) override;
46596     }; // Inst_VOP3__V_LSHLREV_B32
46597
46598     class Inst_VOP3__V_AND_B32 : public Inst_VOP3
46599     {
46600       public:
46601         Inst_VOP3__V_AND_B32(InFmt_VOP3*);
46602         ~Inst_VOP3__V_AND_B32();
46603
46604         int
46605         getNumOperands() override
46606         {
46607             return numDstRegOperands() + numSrcRegOperands();
46608         } // getNumOperands
46609
46610         int numDstRegOperands() override { return 1; }
46611         int numSrcRegOperands() override { return 2; }
46612
46613         int
46614         getOperandSize(int opIdx) override
46615         {
46616             switch (opIdx) {
46617               case 0: //src_0
46618                 return 4;
46619               case 1: //src_1
46620                 return 4;
46621               case 2: //vdst
46622                 return 4;
46623               default:
46624                 fatal("op idx %i out of bounds\n", opIdx);
46625                 return -1;
46626             }
46627         } // getOperandSize
46628
46629         bool
46630         isSrcOperand(int opIdx) override
46631         {
46632             switch (opIdx) {
46633               case 0: //src_0
46634                 return true;
46635               case 1: //src_1
46636                 return true;
46637               case 2: //vdst
46638                 return false;
46639               default:
46640                 fatal("op idx %i out of bounds\n", opIdx);
46641                 return false;
46642             }
46643         } // isSrcOperand
46644
46645         bool
46646         isDstOperand(int opIdx) override
46647         {
46648             switch (opIdx) {
46649               case 0: //src_0
46650                 return false;
46651               case 1: //src_1
46652                 return false;
46653               case 2: //vdst
46654                 return true;
46655               default:
46656                 fatal("op idx %i out of bounds\n", opIdx);
46657                 return false;
46658             }
46659         } // isDstOperand
46660
46661         void execute(GPUDynInstPtr) override;
46662     }; // Inst_VOP3__V_AND_B32
46663
46664     class Inst_VOP3__V_OR_B32 : public Inst_VOP3
46665     {
46666       public:
46667         Inst_VOP3__V_OR_B32(InFmt_VOP3*);
46668         ~Inst_VOP3__V_OR_B32();
46669
46670         int
46671         getNumOperands() override
46672         {
46673             return numDstRegOperands() + numSrcRegOperands();
46674         } // getNumOperands
46675
46676         int numDstRegOperands() override { return 1; }
46677         int numSrcRegOperands() override { return 2; }
46678
46679         int
46680         getOperandSize(int opIdx) override
46681         {
46682             switch (opIdx) {
46683               case 0: //src_0
46684                 return 4;
46685               case 1: //src_1
46686                 return 4;
46687               case 2: //vdst
46688                 return 4;
46689               default:
46690                 fatal("op idx %i out of bounds\n", opIdx);
46691                 return -1;
46692             }
46693         } // getOperandSize
46694
46695         bool
46696         isSrcOperand(int opIdx) override
46697         {
46698             switch (opIdx) {
46699               case 0: //src_0
46700                 return true;
46701               case 1: //src_1
46702                 return true;
46703               case 2: //vdst
46704                 return false;
46705               default:
46706                 fatal("op idx %i out of bounds\n", opIdx);
46707                 return false;
46708             }
46709         } // isSrcOperand
46710
46711         bool
46712         isDstOperand(int opIdx) override
46713         {
46714             switch (opIdx) {
46715               case 0: //src_0
46716                 return false;
46717               case 1: //src_1
46718                 return false;
46719               case 2: //vdst
46720                 return true;
46721               default:
46722                 fatal("op idx %i out of bounds\n", opIdx);
46723                 return false;
46724             }
46725         } // isDstOperand
46726
46727         void execute(GPUDynInstPtr) override;
46728     }; // Inst_VOP3__V_OR_B32
46729
46730     class Inst_VOP3__V_XOR_B32 : public Inst_VOP3
46731     {
46732       public:
46733         Inst_VOP3__V_XOR_B32(InFmt_VOP3*);
46734         ~Inst_VOP3__V_XOR_B32();
46735
46736         int
46737         getNumOperands() override
46738         {
46739             return numDstRegOperands() + numSrcRegOperands();
46740         } // getNumOperands
46741
46742         int numDstRegOperands() override { return 1; }
46743         int numSrcRegOperands() override { return 2; }
46744
46745         int
46746         getOperandSize(int opIdx) override
46747         {
46748             switch (opIdx) {
46749               case 0: //src_0
46750                 return 4;
46751               case 1: //src_1
46752                 return 4;
46753               case 2: //vdst
46754                 return 4;
46755               default:
46756                 fatal("op idx %i out of bounds\n", opIdx);
46757                 return -1;
46758             }
46759         } // getOperandSize
46760
46761         bool
46762         isSrcOperand(int opIdx) override
46763         {
46764             switch (opIdx) {
46765               case 0: //src_0
46766                 return true;
46767               case 1: //src_1
46768                 return true;
46769               case 2: //vdst
46770                 return false;
46771               default:
46772                 fatal("op idx %i out of bounds\n", opIdx);
46773                 return false;
46774             }
46775         } // isSrcOperand
46776
46777         bool
46778         isDstOperand(int opIdx) override
46779         {
46780             switch (opIdx) {
46781               case 0: //src_0
46782                 return false;
46783               case 1: //src_1
46784                 return false;
46785               case 2: //vdst
46786                 return true;
46787               default:
46788                 fatal("op idx %i out of bounds\n", opIdx);
46789                 return false;
46790             }
46791         } // isDstOperand
46792
46793         void execute(GPUDynInstPtr) override;
46794     }; // Inst_VOP3__V_XOR_B32
46795
46796     class Inst_VOP3__V_MAC_F32 : public Inst_VOP3
46797     {
46798       public:
46799         Inst_VOP3__V_MAC_F32(InFmt_VOP3*);
46800         ~Inst_VOP3__V_MAC_F32();
46801
46802         int
46803         getNumOperands() override
46804         {
46805             return numDstRegOperands() + numSrcRegOperands();
46806         } // getNumOperands
46807
46808         int numDstRegOperands() override { return 1; }
46809         int numSrcRegOperands() override { return 2; }
46810
46811         int
46812         getOperandSize(int opIdx) override
46813         {
46814             switch (opIdx) {
46815               case 0: //src_0
46816                 return 4;
46817               case 1: //src_1
46818                 return 4;
46819               case 2: //vdst
46820                 return 4;
46821               default:
46822                 fatal("op idx %i out of bounds\n", opIdx);
46823                 return -1;
46824             }
46825         } // getOperandSize
46826
46827         bool
46828         isSrcOperand(int opIdx) override
46829         {
46830             switch (opIdx) {
46831               case 0: //src_0
46832                 return true;
46833               case 1: //src_1
46834                 return true;
46835               case 2: //vdst
46836                 return false;
46837               default:
46838                 fatal("op idx %i out of bounds\n", opIdx);
46839                 return false;
46840             }
46841         } // isSrcOperand
46842
46843         bool
46844         isDstOperand(int opIdx) override
46845         {
46846             switch (opIdx) {
46847               case 0: //src_0
46848                 return false;
46849               case 1: //src_1
46850                 return false;
46851               case 2: //vdst
46852                 return true;
46853               default:
46854                 fatal("op idx %i out of bounds\n", opIdx);
46855                 return false;
46856             }
46857         } // isDstOperand
46858
46859         void execute(GPUDynInstPtr) override;
46860     }; // Inst_VOP3__V_MAC_F32
46861
46862     class Inst_VOP3__V_ADD_U32 : public Inst_VOP3_SDST_ENC
46863     {
46864       public:
46865         Inst_VOP3__V_ADD_U32(InFmt_VOP3_SDST_ENC*);
46866         ~Inst_VOP3__V_ADD_U32();
46867
46868         int
46869         getNumOperands() override
46870         {
46871             return numDstRegOperands() + numSrcRegOperands();
46872         } // getNumOperands
46873
46874         int numDstRegOperands() override { return 2; }
46875         int numSrcRegOperands() override { return 2; }
46876
46877         int
46878         getOperandSize(int opIdx) override
46879         {
46880             switch (opIdx) {
46881               case 0: //src_0
46882                 return 4;
46883               case 1: //src_1
46884                 return 4;
46885               case 2: //vdst
46886                 return 4;
46887               case 3: //carryout
46888                 return 8;
46889               default:
46890                 fatal("op idx %i out of bounds\n", opIdx);
46891                 return -1;
46892             }
46893         } // getOperandSize
46894
46895         bool
46896         isSrcOperand(int opIdx) override
46897         {
46898             switch (opIdx) {
46899               case 0: //src_0
46900                 return true;
46901               case 1: //src_1
46902                 return true;
46903               case 2: //vdst
46904                 return false;
46905               case 3: //carryout
46906                 return false;
46907               default:
46908                 fatal("op idx %i out of bounds\n", opIdx);
46909                 return false;
46910             }
46911         } // isSrcOperand
46912
46913         bool
46914         isDstOperand(int opIdx) override
46915         {
46916             switch (opIdx) {
46917               case 0: //src_0
46918                 return false;
46919               case 1: //src_1
46920                 return false;
46921               case 2: //vdst
46922                 return true;
46923               case 3: //carryout
46924                 return true;
46925               default:
46926                 fatal("op idx %i out of bounds\n", opIdx);
46927                 return false;
46928             }
46929         } // isDstOperand
46930
46931         void execute(GPUDynInstPtr) override;
46932     }; // Inst_VOP3__V_ADD_U32
46933
46934     class Inst_VOP3__V_SUB_U32 : public Inst_VOP3_SDST_ENC
46935     {
46936       public:
46937         Inst_VOP3__V_SUB_U32(InFmt_VOP3_SDST_ENC*);
46938         ~Inst_VOP3__V_SUB_U32();
46939
46940         int
46941         getNumOperands() override
46942         {
46943             return numDstRegOperands() + numSrcRegOperands();
46944         } // getNumOperands
46945
46946         int numDstRegOperands() override { return 2; }
46947         int numSrcRegOperands() override { return 2; }
46948
46949         int
46950         getOperandSize(int opIdx) override
46951         {
46952             switch (opIdx) {
46953               case 0: //src_0
46954                 return 4;
46955               case 1: //src_1
46956                 return 4;
46957               case 2: //vdst
46958                 return 4;
46959               case 3: //carryout
46960                 return 8;
46961               default:
46962                 fatal("op idx %i out of bounds\n", opIdx);
46963                 return -1;
46964             }
46965         } // getOperandSize
46966
46967         bool
46968         isSrcOperand(int opIdx) override
46969         {
46970             switch (opIdx) {
46971               case 0: //src_0
46972                 return true;
46973               case 1: //src_1
46974                 return true;
46975               case 2: //vdst
46976                 return false;
46977               case 3: //carryout
46978                 return false;
46979               default:
46980                 fatal("op idx %i out of bounds\n", opIdx);
46981                 return false;
46982             }
46983         } // isSrcOperand
46984
46985         bool
46986         isDstOperand(int opIdx) override
46987         {
46988             switch (opIdx) {
46989               case 0: //src_0
46990                 return false;
46991               case 1: //src_1
46992                 return false;
46993               case 2: //vdst
46994                 return true;
46995               case 3: //carryout
46996                 return true;
46997               default:
46998                 fatal("op idx %i out of bounds\n", opIdx);
46999                 return false;
47000             }
47001         } // isDstOperand
47002
47003         void execute(GPUDynInstPtr) override;
47004     }; // Inst_VOP3__V_SUB_U32
47005
47006     class Inst_VOP3__V_SUBREV_U32 : public Inst_VOP3_SDST_ENC
47007     {
47008       public:
47009         Inst_VOP3__V_SUBREV_U32(InFmt_VOP3_SDST_ENC*);
47010         ~Inst_VOP3__V_SUBREV_U32();
47011
47012         int
47013         getNumOperands() override
47014         {
47015             return numDstRegOperands() + numSrcRegOperands();
47016         } // getNumOperands
47017
47018         int numDstRegOperands() override { return 2; }
47019         int numSrcRegOperands() override { return 2; }
47020
47021         int
47022         getOperandSize(int opIdx) override
47023         {
47024             switch (opIdx) {
47025               case 0: //src_0
47026                 return 4;
47027               case 1: //src_1
47028                 return 4;
47029               case 2: //vdst
47030                 return 4;
47031               case 3: //carryout
47032                 return 8;
47033               default:
47034                 fatal("op idx %i out of bounds\n", opIdx);
47035                 return -1;
47036             }
47037         } // getOperandSize
47038
47039         bool
47040         isSrcOperand(int opIdx) override
47041         {
47042             switch (opIdx) {
47043               case 0: //src_0
47044                 return true;
47045               case 1: //src_1
47046                 return true;
47047               case 2: //vdst
47048                 return false;
47049               case 3: //carryout
47050                 return false;
47051               default:
47052                 fatal("op idx %i out of bounds\n", opIdx);
47053                 return false;
47054             }
47055         } // isSrcOperand
47056
47057         bool
47058         isDstOperand(int opIdx) override
47059         {
47060             switch (opIdx) {
47061               case 0: //src_0
47062                 return false;
47063               case 1: //src_1
47064                 return false;
47065               case 2: //vdst
47066                 return true;
47067               case 3: //carryout
47068                 return true;
47069               default:
47070                 fatal("op idx %i out of bounds\n", opIdx);
47071                 return false;
47072             }
47073         } // isDstOperand
47074
47075         void execute(GPUDynInstPtr) override;
47076     }; // Inst_VOP3__V_SUBREV_U32
47077
47078     class Inst_VOP3__V_ADDC_U32 : public Inst_VOP3_SDST_ENC
47079     {
47080       public:
47081         Inst_VOP3__V_ADDC_U32(InFmt_VOP3_SDST_ENC*);
47082         ~Inst_VOP3__V_ADDC_U32();
47083
47084         int
47085         getNumOperands() override
47086         {
47087             return numDstRegOperands() + numSrcRegOperands();
47088         } // getNumOperands
47089
47090         int numDstRegOperands() override { return 2; }
47091         int numSrcRegOperands() override { return 3; }
47092
47093         int
47094         getOperandSize(int opIdx) override
47095         {
47096             switch (opIdx) {
47097               case 0: //src_0
47098                 return 4;
47099               case 1: //src_1
47100                 return 4;
47101               case 2: //carryin
47102                 return 8;
47103               case 3: //vdst
47104                 return 4;
47105               case 4: //carryout
47106                 return 8;
47107               default:
47108                 fatal("op idx %i out of bounds\n", opIdx);
47109                 return -1;
47110             }
47111         } // getOperandSize
47112
47113         bool
47114         isSrcOperand(int opIdx) override
47115         {
47116             switch (opIdx) {
47117               case 0: //src_0
47118                 return true;
47119               case 1: //src_1
47120                 return true;
47121               case 2: //carryin
47122                 return true;
47123               case 3: //vdst
47124                 return false;
47125               case 4: //carryout
47126                 return false;
47127               default:
47128                 fatal("op idx %i out of bounds\n", opIdx);
47129                 return false;
47130             }
47131         } // isSrcOperand
47132
47133         bool
47134         isDstOperand(int opIdx) override
47135         {
47136             switch (opIdx) {
47137               case 0: //src_0
47138                 return false;
47139               case 1: //src_1
47140                 return false;
47141               case 2: //carryin
47142                 return false;
47143               case 3: //vdst
47144                 return true;
47145               case 4: //carryout
47146                 return true;
47147               default:
47148                 fatal("op idx %i out of bounds\n", opIdx);
47149                 return false;
47150             }
47151         } // isDstOperand
47152
47153         void execute(GPUDynInstPtr) override;
47154     }; // Inst_VOP3__V_ADDC_U32
47155
47156     class Inst_VOP3__V_SUBB_U32 : public Inst_VOP3_SDST_ENC
47157     {
47158       public:
47159         Inst_VOP3__V_SUBB_U32(InFmt_VOP3_SDST_ENC*);
47160         ~Inst_VOP3__V_SUBB_U32();
47161
47162         int
47163         getNumOperands() override
47164         {
47165             return numDstRegOperands() + numSrcRegOperands();
47166         } // getNumOperands
47167
47168         int numDstRegOperands() override { return 2; }
47169         int numSrcRegOperands() override { return 3; }
47170
47171         int
47172         getOperandSize(int opIdx) override
47173         {
47174             switch (opIdx) {
47175               case 0: //src_0
47176                 return 4;
47177               case 1: //src_1
47178                 return 4;
47179               case 2: //carryin
47180                 return 8;
47181               case 3: //vdst
47182                 return 4;
47183               case 4: //carryout
47184                 return 8;
47185               default:
47186                 fatal("op idx %i out of bounds\n", opIdx);
47187                 return -1;
47188             }
47189         } // getOperandSize
47190
47191         bool
47192         isSrcOperand(int opIdx) override
47193         {
47194             switch (opIdx) {
47195               case 0: //src_0
47196                 return true;
47197               case 1: //src_1
47198                 return true;
47199               case 2: //carryin
47200                 return true;
47201               case 3: //vdst
47202                 return false;
47203               case 4: //carryout
47204                 return false;
47205               default:
47206                 fatal("op idx %i out of bounds\n", opIdx);
47207                 return false;
47208             }
47209         } // isSrcOperand
47210
47211         bool
47212         isDstOperand(int opIdx) override
47213         {
47214             switch (opIdx) {
47215               case 0: //src_0
47216                 return false;
47217               case 1: //src_1
47218                 return false;
47219               case 2: //carryin
47220                 return false;
47221               case 3: //vdst
47222                 return true;
47223               case 4: //carryout
47224                 return true;
47225               default:
47226                 fatal("op idx %i out of bounds\n", opIdx);
47227                 return false;
47228             }
47229         } // isDstOperand
47230
47231         void execute(GPUDynInstPtr) override;
47232     }; // Inst_VOP3__V_SUBB_U32
47233
47234     class Inst_VOP3__V_SUBBREV_U32 : public Inst_VOP3_SDST_ENC
47235     {
47236       public:
47237         Inst_VOP3__V_SUBBREV_U32(InFmt_VOP3_SDST_ENC*);
47238         ~Inst_VOP3__V_SUBBREV_U32();
47239
47240         int
47241         getNumOperands() override
47242         {
47243             return numDstRegOperands() + numSrcRegOperands();
47244         } // getNumOperands
47245
47246         int numDstRegOperands() override { return 2; }
47247         int numSrcRegOperands() override { return 3; }
47248
47249         int
47250         getOperandSize(int opIdx) override
47251         {
47252             switch (opIdx) {
47253               case 0: //src_0
47254                 return 4;
47255               case 1: //src_1
47256                 return 4;
47257               case 2: //carryin
47258                 return 8;
47259               case 3: //vdst
47260                 return 4;
47261               case 4: //carryout
47262                 return 8;
47263               default:
47264                 fatal("op idx %i out of bounds\n", opIdx);
47265                 return -1;
47266             }
47267         } // getOperandSize
47268
47269         bool
47270         isSrcOperand(int opIdx) override
47271         {
47272             switch (opIdx) {
47273               case 0: //src_0
47274                 return true;
47275               case 1: //src_1
47276                 return true;
47277               case 2: //carryin
47278                 return true;
47279               case 3: //vdst
47280                 return false;
47281               case 4: //carryout
47282                 return false;
47283               default:
47284                 fatal("op idx %i out of bounds\n", opIdx);
47285                 return false;
47286             }
47287         } // isSrcOperand
47288
47289         bool
47290         isDstOperand(int opIdx) override
47291         {
47292             switch (opIdx) {
47293               case 0: //src_0
47294                 return false;
47295               case 1: //src_1
47296                 return false;
47297               case 2: //carryin
47298                 return false;
47299               case 3: //vdst
47300                 return true;
47301               case 4: //carryout
47302                 return true;
47303               default:
47304                 fatal("op idx %i out of bounds\n", opIdx);
47305                 return false;
47306             }
47307         } // isDstOperand
47308
47309         void execute(GPUDynInstPtr) override;
47310     }; // Inst_VOP3__V_SUBBREV_U32
47311
47312     class Inst_VOP3__V_ADD_F16 : public Inst_VOP3
47313     {
47314       public:
47315         Inst_VOP3__V_ADD_F16(InFmt_VOP3*);
47316         ~Inst_VOP3__V_ADD_F16();
47317
47318         int
47319         getNumOperands() override
47320         {
47321             return numDstRegOperands() + numSrcRegOperands();
47322         } // getNumOperands
47323
47324         int numDstRegOperands() override { return 1; }
47325         int numSrcRegOperands() override { return 2; }
47326
47327         int
47328         getOperandSize(int opIdx) override
47329         {
47330             switch (opIdx) {
47331               case 0: //src_0
47332                 return 2;
47333               case 1: //src_1
47334                 return 2;
47335               case 2: //vdst
47336                 return 2;
47337               default:
47338                 fatal("op idx %i out of bounds\n", opIdx);
47339                 return -1;
47340             }
47341         } // getOperandSize
47342
47343         bool
47344         isSrcOperand(int opIdx) override
47345         {
47346             switch (opIdx) {
47347               case 0: //src_0
47348                 return true;
47349               case 1: //src_1
47350                 return true;
47351               case 2: //vdst
47352                 return false;
47353               default:
47354                 fatal("op idx %i out of bounds\n", opIdx);
47355                 return false;
47356             }
47357         } // isSrcOperand
47358
47359         bool
47360         isDstOperand(int opIdx) override
47361         {
47362             switch (opIdx) {
47363               case 0: //src_0
47364                 return false;
47365               case 1: //src_1
47366                 return false;
47367               case 2: //vdst
47368                 return true;
47369               default:
47370                 fatal("op idx %i out of bounds\n", opIdx);
47371                 return false;
47372             }
47373         } // isDstOperand
47374
47375         void execute(GPUDynInstPtr) override;
47376     }; // Inst_VOP3__V_ADD_F16
47377
47378     class Inst_VOP3__V_SUB_F16 : public Inst_VOP3
47379     {
47380       public:
47381         Inst_VOP3__V_SUB_F16(InFmt_VOP3*);
47382         ~Inst_VOP3__V_SUB_F16();
47383
47384         int
47385         getNumOperands() override
47386         {
47387             return numDstRegOperands() + numSrcRegOperands();
47388         } // getNumOperands
47389
47390         int numDstRegOperands() override { return 1; }
47391         int numSrcRegOperands() override { return 2; }
47392
47393         int
47394         getOperandSize(int opIdx) override
47395         {
47396             switch (opIdx) {
47397               case 0: //src_0
47398                 return 2;
47399               case 1: //src_1
47400                 return 2;
47401               case 2: //vdst
47402                 return 2;
47403               default:
47404                 fatal("op idx %i out of bounds\n", opIdx);
47405                 return -1;
47406             }
47407         } // getOperandSize
47408
47409         bool
47410         isSrcOperand(int opIdx) override
47411         {
47412             switch (opIdx) {
47413               case 0: //src_0
47414                 return true;
47415               case 1: //src_1
47416                 return true;
47417               case 2: //vdst
47418                 return false;
47419               default:
47420                 fatal("op idx %i out of bounds\n", opIdx);
47421                 return false;
47422             }
47423         } // isSrcOperand
47424
47425         bool
47426         isDstOperand(int opIdx) override
47427         {
47428             switch (opIdx) {
47429               case 0: //src_0
47430                 return false;
47431               case 1: //src_1
47432                 return false;
47433               case 2: //vdst
47434                 return true;
47435               default:
47436                 fatal("op idx %i out of bounds\n", opIdx);
47437                 return false;
47438             }
47439         } // isDstOperand
47440
47441         void execute(GPUDynInstPtr) override;
47442     }; // Inst_VOP3__V_SUB_F16
47443
47444     class Inst_VOP3__V_SUBREV_F16 : public Inst_VOP3
47445     {
47446       public:
47447         Inst_VOP3__V_SUBREV_F16(InFmt_VOP3*);
47448         ~Inst_VOP3__V_SUBREV_F16();
47449
47450         int
47451         getNumOperands() override
47452         {
47453             return numDstRegOperands() + numSrcRegOperands();
47454         } // getNumOperands
47455
47456         int numDstRegOperands() override { return 1; }
47457         int numSrcRegOperands() override { return 2; }
47458
47459         int
47460         getOperandSize(int opIdx) override
47461         {
47462             switch (opIdx) {
47463               case 0: //src_0
47464                 return 2;
47465               case 1: //src_1
47466                 return 2;
47467               case 2: //vdst
47468                 return 2;
47469               default:
47470                 fatal("op idx %i out of bounds\n", opIdx);
47471                 return -1;
47472             }
47473         } // getOperandSize
47474
47475         bool
47476         isSrcOperand(int opIdx) override
47477         {
47478             switch (opIdx) {
47479               case 0: //src_0
47480                 return true;
47481               case 1: //src_1
47482                 return true;
47483               case 2: //vdst
47484                 return false;
47485               default:
47486                 fatal("op idx %i out of bounds\n", opIdx);
47487                 return false;
47488             }
47489         } // isSrcOperand
47490
47491         bool
47492         isDstOperand(int opIdx) override
47493         {
47494             switch (opIdx) {
47495               case 0: //src_0
47496                 return false;
47497               case 1: //src_1
47498                 return false;
47499               case 2: //vdst
47500                 return true;
47501               default:
47502                 fatal("op idx %i out of bounds\n", opIdx);
47503                 return false;
47504             }
47505         } // isDstOperand
47506
47507         void execute(GPUDynInstPtr) override;
47508     }; // Inst_VOP3__V_SUBREV_F16
47509
47510     class Inst_VOP3__V_MUL_F16 : public Inst_VOP3
47511     {
47512       public:
47513         Inst_VOP3__V_MUL_F16(InFmt_VOP3*);
47514         ~Inst_VOP3__V_MUL_F16();
47515
47516         int
47517         getNumOperands() override
47518         {
47519             return numDstRegOperands() + numSrcRegOperands();
47520         } // getNumOperands
47521
47522         int numDstRegOperands() override { return 1; }
47523         int numSrcRegOperands() override { return 2; }
47524
47525         int
47526         getOperandSize(int opIdx) override
47527         {
47528             switch (opIdx) {
47529               case 0: //src_0
47530                 return 2;
47531               case 1: //src_1
47532                 return 2;
47533               case 2: //vdst
47534                 return 2;
47535               default:
47536                 fatal("op idx %i out of bounds\n", opIdx);
47537                 return -1;
47538             }
47539         } // getOperandSize
47540
47541         bool
47542         isSrcOperand(int opIdx) override
47543         {
47544             switch (opIdx) {
47545               case 0: //src_0
47546                 return true;
47547               case 1: //src_1
47548                 return true;
47549               case 2: //vdst
47550                 return false;
47551               default:
47552                 fatal("op idx %i out of bounds\n", opIdx);
47553                 return false;
47554             }
47555         } // isSrcOperand
47556
47557         bool
47558         isDstOperand(int opIdx) override
47559         {
47560             switch (opIdx) {
47561               case 0: //src_0
47562                 return false;
47563               case 1: //src_1
47564                 return false;
47565               case 2: //vdst
47566                 return true;
47567               default:
47568                 fatal("op idx %i out of bounds\n", opIdx);
47569                 return false;
47570             }
47571         } // isDstOperand
47572
47573         void execute(GPUDynInstPtr) override;
47574     }; // Inst_VOP3__V_MUL_F16
47575
47576     class Inst_VOP3__V_MAC_F16 : public Inst_VOP3
47577     {
47578       public:
47579         Inst_VOP3__V_MAC_F16(InFmt_VOP3*);
47580         ~Inst_VOP3__V_MAC_F16();
47581
47582         int
47583         getNumOperands() override
47584         {
47585             return numDstRegOperands() + numSrcRegOperands();
47586         } // getNumOperands
47587
47588         int numDstRegOperands() override { return 1; }
47589         int numSrcRegOperands() override { return 2; }
47590
47591         int
47592         getOperandSize(int opIdx) override
47593         {
47594             switch (opIdx) {
47595               case 0: //src_0
47596                 return 2;
47597               case 1: //src_1
47598                 return 2;
47599               case 2: //vdst
47600                 return 2;
47601               default:
47602                 fatal("op idx %i out of bounds\n", opIdx);
47603                 return -1;
47604             }
47605         } // getOperandSize
47606
47607         bool
47608         isSrcOperand(int opIdx) override
47609         {
47610             switch (opIdx) {
47611               case 0: //src_0
47612                 return true;
47613               case 1: //src_1
47614                 return true;
47615               case 2: //vdst
47616                 return false;
47617               default:
47618                 fatal("op idx %i out of bounds\n", opIdx);
47619                 return false;
47620             }
47621         } // isSrcOperand
47622
47623         bool
47624         isDstOperand(int opIdx) override
47625         {
47626             switch (opIdx) {
47627               case 0: //src_0
47628                 return false;
47629               case 1: //src_1
47630                 return false;
47631               case 2: //vdst
47632                 return true;
47633               default:
47634                 fatal("op idx %i out of bounds\n", opIdx);
47635                 return false;
47636             }
47637         } // isDstOperand
47638
47639         void execute(GPUDynInstPtr) override;
47640     }; // Inst_VOP3__V_MAC_F16
47641
47642     class Inst_VOP3__V_ADD_U16 : public Inst_VOP3
47643     {
47644       public:
47645         Inst_VOP3__V_ADD_U16(InFmt_VOP3*);
47646         ~Inst_VOP3__V_ADD_U16();
47647
47648         int
47649         getNumOperands() override
47650         {
47651             return numDstRegOperands() + numSrcRegOperands();
47652         } // getNumOperands
47653
47654         int numDstRegOperands() override { return 1; }
47655         int numSrcRegOperands() override { return 2; }
47656
47657         int
47658         getOperandSize(int opIdx) override
47659         {
47660             switch (opIdx) {
47661               case 0: //src_0
47662                 return 2;
47663               case 1: //src_1
47664                 return 2;
47665               case 2: //vdst
47666                 return 2;
47667               default:
47668                 fatal("op idx %i out of bounds\n", opIdx);
47669                 return -1;
47670             }
47671         } // getOperandSize
47672
47673         bool
47674         isSrcOperand(int opIdx) override
47675         {
47676             switch (opIdx) {
47677               case 0: //src_0
47678                 return true;
47679               case 1: //src_1
47680                 return true;
47681               case 2: //vdst
47682                 return false;
47683               default:
47684                 fatal("op idx %i out of bounds\n", opIdx);
47685                 return false;
47686             }
47687         } // isSrcOperand
47688
47689         bool
47690         isDstOperand(int opIdx) override
47691         {
47692             switch (opIdx) {
47693               case 0: //src_0
47694                 return false;
47695               case 1: //src_1
47696                 return false;
47697               case 2: //vdst
47698                 return true;
47699               default:
47700                 fatal("op idx %i out of bounds\n", opIdx);
47701                 return false;
47702             }
47703         } // isDstOperand
47704
47705         void execute(GPUDynInstPtr) override;
47706     }; // Inst_VOP3__V_ADD_U16
47707
47708     class Inst_VOP3__V_SUB_U16 : public Inst_VOP3
47709     {
47710       public:
47711         Inst_VOP3__V_SUB_U16(InFmt_VOP3*);
47712         ~Inst_VOP3__V_SUB_U16();
47713
47714         int
47715         getNumOperands() override
47716         {
47717             return numDstRegOperands() + numSrcRegOperands();
47718         } // getNumOperands
47719
47720         int numDstRegOperands() override { return 1; }
47721         int numSrcRegOperands() override { return 2; }
47722
47723         int
47724         getOperandSize(int opIdx) override
47725         {
47726             switch (opIdx) {
47727               case 0: //src_0
47728                 return 2;
47729               case 1: //src_1
47730                 return 2;
47731               case 2: //vdst
47732                 return 2;
47733               default:
47734                 fatal("op idx %i out of bounds\n", opIdx);
47735                 return -1;
47736             }
47737         } // getOperandSize
47738
47739         bool
47740         isSrcOperand(int opIdx) override
47741         {
47742             switch (opIdx) {
47743               case 0: //src_0
47744                 return true;
47745               case 1: //src_1
47746                 return true;
47747               case 2: //vdst
47748                 return false;
47749               default:
47750                 fatal("op idx %i out of bounds\n", opIdx);
47751                 return false;
47752             }
47753         } // isSrcOperand
47754
47755         bool
47756         isDstOperand(int opIdx) override
47757         {
47758             switch (opIdx) {
47759               case 0: //src_0
47760                 return false;
47761               case 1: //src_1
47762                 return false;
47763               case 2: //vdst
47764                 return true;
47765               default:
47766                 fatal("op idx %i out of bounds\n", opIdx);
47767                 return false;
47768             }
47769         } // isDstOperand
47770
47771         void execute(GPUDynInstPtr) override;
47772     }; // Inst_VOP3__V_SUB_U16
47773
47774     class Inst_VOP3__V_SUBREV_U16 : public Inst_VOP3
47775     {
47776       public:
47777         Inst_VOP3__V_SUBREV_U16(InFmt_VOP3*);
47778         ~Inst_VOP3__V_SUBREV_U16();
47779
47780         int
47781         getNumOperands() override
47782         {
47783             return numDstRegOperands() + numSrcRegOperands();
47784         } // getNumOperands
47785
47786         int numDstRegOperands() override { return 1; }
47787         int numSrcRegOperands() override { return 2; }
47788
47789         int
47790         getOperandSize(int opIdx) override
47791         {
47792             switch (opIdx) {
47793               case 0: //src_0
47794                 return 2;
47795               case 1: //src_1
47796                 return 2;
47797               case 2: //vdst
47798                 return 2;
47799               default:
47800                 fatal("op idx %i out of bounds\n", opIdx);
47801                 return -1;
47802             }
47803         } // getOperandSize
47804
47805         bool
47806         isSrcOperand(int opIdx) override
47807         {
47808             switch (opIdx) {
47809               case 0: //src_0
47810                 return true;
47811               case 1: //src_1
47812                 return true;
47813               case 2: //vdst
47814                 return false;
47815               default:
47816                 fatal("op idx %i out of bounds\n", opIdx);
47817                 return false;
47818             }
47819         } // isSrcOperand
47820
47821         bool
47822         isDstOperand(int opIdx) override
47823         {
47824             switch (opIdx) {
47825               case 0: //src_0
47826                 return false;
47827               case 1: //src_1
47828                 return false;
47829               case 2: //vdst
47830                 return true;
47831               default:
47832                 fatal("op idx %i out of bounds\n", opIdx);
47833                 return false;
47834             }
47835         } // isDstOperand
47836
47837         void execute(GPUDynInstPtr) override;
47838     }; // Inst_VOP3__V_SUBREV_U16
47839
47840     class Inst_VOP3__V_MUL_LO_U16 : public Inst_VOP3
47841     {
47842       public:
47843         Inst_VOP3__V_MUL_LO_U16(InFmt_VOP3*);
47844         ~Inst_VOP3__V_MUL_LO_U16();
47845
47846         int
47847         getNumOperands() override
47848         {
47849             return numDstRegOperands() + numSrcRegOperands();
47850         } // getNumOperands
47851
47852         int numDstRegOperands() override { return 1; }
47853         int numSrcRegOperands() override { return 2; }
47854
47855         int
47856         getOperandSize(int opIdx) override
47857         {
47858             switch (opIdx) {
47859               case 0: //src_0
47860                 return 2;
47861               case 1: //src_1
47862                 return 2;
47863               case 2: //vdst
47864                 return 2;
47865               default:
47866                 fatal("op idx %i out of bounds\n", opIdx);
47867                 return -1;
47868             }
47869         } // getOperandSize
47870
47871         bool
47872         isSrcOperand(int opIdx) override
47873         {
47874             switch (opIdx) {
47875               case 0: //src_0
47876                 return true;
47877               case 1: //src_1
47878                 return true;
47879               case 2: //vdst
47880                 return false;
47881               default:
47882                 fatal("op idx %i out of bounds\n", opIdx);
47883                 return false;
47884             }
47885         } // isSrcOperand
47886
47887         bool
47888         isDstOperand(int opIdx) override
47889         {
47890             switch (opIdx) {
47891               case 0: //src_0
47892                 return false;
47893               case 1: //src_1
47894                 return false;
47895               case 2: //vdst
47896                 return true;
47897               default:
47898                 fatal("op idx %i out of bounds\n", opIdx);
47899                 return false;
47900             }
47901         } // isDstOperand
47902
47903         void execute(GPUDynInstPtr) override;
47904     }; // Inst_VOP3__V_MUL_LO_U16
47905
47906     class Inst_VOP3__V_LSHLREV_B16 : public Inst_VOP3
47907     {
47908       public:
47909         Inst_VOP3__V_LSHLREV_B16(InFmt_VOP3*);
47910         ~Inst_VOP3__V_LSHLREV_B16();
47911
47912         int
47913         getNumOperands() override
47914         {
47915             return numDstRegOperands() + numSrcRegOperands();
47916         } // getNumOperands
47917
47918         int numDstRegOperands() override { return 1; }
47919         int numSrcRegOperands() override { return 2; }
47920
47921         int
47922         getOperandSize(int opIdx) override
47923         {
47924             switch (opIdx) {
47925               case 0: //src_0
47926                 return 2;
47927               case 1: //src_1
47928                 return 2;
47929               case 2: //vdst
47930                 return 2;
47931               default:
47932                 fatal("op idx %i out of bounds\n", opIdx);
47933                 return -1;
47934             }
47935         } // getOperandSize
47936
47937         bool
47938         isSrcOperand(int opIdx) override
47939         {
47940             switch (opIdx) {
47941               case 0: //src_0
47942                 return true;
47943               case 1: //src_1
47944                 return true;
47945               case 2: //vdst
47946                 return false;
47947               default:
47948                 fatal("op idx %i out of bounds\n", opIdx);
47949                 return false;
47950             }
47951         } // isSrcOperand
47952
47953         bool
47954         isDstOperand(int opIdx) override
47955         {
47956             switch (opIdx) {
47957               case 0: //src_0
47958                 return false;
47959               case 1: //src_1
47960                 return false;
47961               case 2: //vdst
47962                 return true;
47963               default:
47964                 fatal("op idx %i out of bounds\n", opIdx);
47965                 return false;
47966             }
47967         } // isDstOperand
47968
47969         void execute(GPUDynInstPtr) override;
47970     }; // Inst_VOP3__V_LSHLREV_B16
47971
47972     class Inst_VOP3__V_LSHRREV_B16 : public Inst_VOP3
47973     {
47974       public:
47975         Inst_VOP3__V_LSHRREV_B16(InFmt_VOP3*);
47976         ~Inst_VOP3__V_LSHRREV_B16();
47977
47978         int
47979         getNumOperands() override
47980         {
47981             return numDstRegOperands() + numSrcRegOperands();
47982         } // getNumOperands
47983
47984         int numDstRegOperands() override { return 1; }
47985         int numSrcRegOperands() override { return 2; }
47986
47987         int
47988         getOperandSize(int opIdx) override
47989         {
47990             switch (opIdx) {
47991               case 0: //src_0
47992                 return 2;
47993               case 1: //src_1
47994                 return 2;
47995               case 2: //vdst
47996                 return 2;
47997               default:
47998                 fatal("op idx %i out of bounds\n", opIdx);
47999                 return -1;
48000             }
48001         } // getOperandSize
48002
48003         bool
48004         isSrcOperand(int opIdx) override
48005         {
48006             switch (opIdx) {
48007               case 0: //src_0
48008                 return true;
48009               case 1: //src_1
48010                 return true;
48011               case 2: //vdst
48012                 return false;
48013               default:
48014                 fatal("op idx %i out of bounds\n", opIdx);
48015                 return false;
48016             }
48017         } // isSrcOperand
48018
48019         bool
48020         isDstOperand(int opIdx) override
48021         {
48022             switch (opIdx) {
48023               case 0: //src_0
48024                 return false;
48025               case 1: //src_1
48026                 return false;
48027               case 2: //vdst
48028                 return true;
48029               default:
48030                 fatal("op idx %i out of bounds\n", opIdx);
48031                 return false;
48032             }
48033         } // isDstOperand
48034
48035         void execute(GPUDynInstPtr) override;
48036     }; // Inst_VOP3__V_LSHRREV_B16
48037
48038     class Inst_VOP3__V_ASHRREV_I16 : public Inst_VOP3
48039     {
48040       public:
48041         Inst_VOP3__V_ASHRREV_I16(InFmt_VOP3*);
48042         ~Inst_VOP3__V_ASHRREV_I16();
48043
48044         int
48045         getNumOperands() override
48046         {
48047             return numDstRegOperands() + numSrcRegOperands();
48048         } // getNumOperands
48049
48050         int numDstRegOperands() override { return 1; }
48051         int numSrcRegOperands() override { return 2; }
48052
48053         int
48054         getOperandSize(int opIdx) override
48055         {
48056             switch (opIdx) {
48057               case 0: //src_0
48058                 return 2;
48059               case 1: //src_1
48060                 return 2;
48061               case 2: //vdst
48062                 return 2;
48063               default:
48064                 fatal("op idx %i out of bounds\n", opIdx);
48065                 return -1;
48066             }
48067         } // getOperandSize
48068
48069         bool
48070         isSrcOperand(int opIdx) override
48071         {
48072             switch (opIdx) {
48073               case 0: //src_0
48074                 return true;
48075               case 1: //src_1
48076                 return true;
48077               case 2: //vdst
48078                 return false;
48079               default:
48080                 fatal("op idx %i out of bounds\n", opIdx);
48081                 return false;
48082             }
48083         } // isSrcOperand
48084
48085         bool
48086         isDstOperand(int opIdx) override
48087         {
48088             switch (opIdx) {
48089               case 0: //src_0
48090                 return false;
48091               case 1: //src_1
48092                 return false;
48093               case 2: //vdst
48094                 return true;
48095               default:
48096                 fatal("op idx %i out of bounds\n", opIdx);
48097                 return false;
48098             }
48099         } // isDstOperand
48100
48101         void execute(GPUDynInstPtr) override;
48102     }; // Inst_VOP3__V_ASHRREV_I16
48103
48104     class Inst_VOP3__V_MAX_F16 : public Inst_VOP3
48105     {
48106       public:
48107         Inst_VOP3__V_MAX_F16(InFmt_VOP3*);
48108         ~Inst_VOP3__V_MAX_F16();
48109
48110         int
48111         getNumOperands() override
48112         {
48113             return numDstRegOperands() + numSrcRegOperands();
48114         } // getNumOperands
48115
48116         int numDstRegOperands() override { return 1; }
48117         int numSrcRegOperands() override { return 2; }
48118
48119         int
48120         getOperandSize(int opIdx) override
48121         {
48122             switch (opIdx) {
48123               case 0: //src_0
48124                 return 2;
48125               case 1: //src_1
48126                 return 2;
48127               case 2: //vdst
48128                 return 2;
48129               default:
48130                 fatal("op idx %i out of bounds\n", opIdx);
48131                 return -1;
48132             }
48133         } // getOperandSize
48134
48135         bool
48136         isSrcOperand(int opIdx) override
48137         {
48138             switch (opIdx) {
48139               case 0: //src_0
48140                 return true;
48141               case 1: //src_1
48142                 return true;
48143               case 2: //vdst
48144                 return false;
48145               default:
48146                 fatal("op idx %i out of bounds\n", opIdx);
48147                 return false;
48148             }
48149         } // isSrcOperand
48150
48151         bool
48152         isDstOperand(int opIdx) override
48153         {
48154             switch (opIdx) {
48155               case 0: //src_0
48156                 return false;
48157               case 1: //src_1
48158                 return false;
48159               case 2: //vdst
48160                 return true;
48161               default:
48162                 fatal("op idx %i out of bounds\n", opIdx);
48163                 return false;
48164             }
48165         } // isDstOperand
48166
48167         void execute(GPUDynInstPtr) override;
48168     }; // Inst_VOP3__V_MAX_F16
48169
48170     class Inst_VOP3__V_MIN_F16 : public Inst_VOP3
48171     {
48172       public:
48173         Inst_VOP3__V_MIN_F16(InFmt_VOP3*);
48174         ~Inst_VOP3__V_MIN_F16();
48175
48176         int
48177         getNumOperands() override
48178         {
48179             return numDstRegOperands() + numSrcRegOperands();
48180         } // getNumOperands
48181
48182         int numDstRegOperands() override { return 1; }
48183         int numSrcRegOperands() override { return 2; }
48184
48185         int
48186         getOperandSize(int opIdx) override
48187         {
48188             switch (opIdx) {
48189               case 0: //src_0
48190                 return 2;
48191               case 1: //src_1
48192                 return 2;
48193               case 2: //vdst
48194                 return 2;
48195               default:
48196                 fatal("op idx %i out of bounds\n", opIdx);
48197                 return -1;
48198             }
48199         } // getOperandSize
48200
48201         bool
48202         isSrcOperand(int opIdx) override
48203         {
48204             switch (opIdx) {
48205               case 0: //src_0
48206                 return true;
48207               case 1: //src_1
48208                 return true;
48209               case 2: //vdst
48210                 return false;
48211               default:
48212                 fatal("op idx %i out of bounds\n", opIdx);
48213                 return false;
48214             }
48215         } // isSrcOperand
48216
48217         bool
48218         isDstOperand(int opIdx) override
48219         {
48220             switch (opIdx) {
48221               case 0: //src_0
48222                 return false;
48223               case 1: //src_1
48224                 return false;
48225               case 2: //vdst
48226                 return true;
48227               default:
48228                 fatal("op idx %i out of bounds\n", opIdx);
48229                 return false;
48230             }
48231         } // isDstOperand
48232
48233         void execute(GPUDynInstPtr) override;
48234     }; // Inst_VOP3__V_MIN_F16
48235
48236     class Inst_VOP3__V_MAX_U16 : public Inst_VOP3
48237     {
48238       public:
48239         Inst_VOP3__V_MAX_U16(InFmt_VOP3*);
48240         ~Inst_VOP3__V_MAX_U16();
48241
48242         int
48243         getNumOperands() override
48244         {
48245             return numDstRegOperands() + numSrcRegOperands();
48246         } // getNumOperands
48247
48248         int numDstRegOperands() override { return 1; }
48249         int numSrcRegOperands() override { return 2; }
48250
48251         int
48252         getOperandSize(int opIdx) override
48253         {
48254             switch (opIdx) {
48255               case 0: //src_0
48256                 return 2;
48257               case 1: //src_1
48258                 return 2;
48259               case 2: //vdst
48260                 return 2;
48261               default:
48262                 fatal("op idx %i out of bounds\n", opIdx);
48263                 return -1;
48264             }
48265         } // getOperandSize
48266
48267         bool
48268         isSrcOperand(int opIdx) override
48269         {
48270             switch (opIdx) {
48271               case 0: //src_0
48272                 return true;
48273               case 1: //src_1
48274                 return true;
48275               case 2: //vdst
48276                 return false;
48277               default:
48278                 fatal("op idx %i out of bounds\n", opIdx);
48279                 return false;
48280             }
48281         } // isSrcOperand
48282
48283         bool
48284         isDstOperand(int opIdx) override
48285         {
48286             switch (opIdx) {
48287               case 0: //src_0
48288                 return false;
48289               case 1: //src_1
48290                 return false;
48291               case 2: //vdst
48292                 return true;
48293               default:
48294                 fatal("op idx %i out of bounds\n", opIdx);
48295                 return false;
48296             }
48297         } // isDstOperand
48298
48299         void execute(GPUDynInstPtr) override;
48300     }; // Inst_VOP3__V_MAX_U16
48301
48302     class Inst_VOP3__V_MAX_I16 : public Inst_VOP3
48303     {
48304       public:
48305         Inst_VOP3__V_MAX_I16(InFmt_VOP3*);
48306         ~Inst_VOP3__V_MAX_I16();
48307
48308         int
48309         getNumOperands() override
48310         {
48311             return numDstRegOperands() + numSrcRegOperands();
48312         } // getNumOperands
48313
48314         int numDstRegOperands() override { return 1; }
48315         int numSrcRegOperands() override { return 2; }
48316
48317         int
48318         getOperandSize(int opIdx) override
48319         {
48320             switch (opIdx) {
48321               case 0: //src_0
48322                 return 2;
48323               case 1: //src_1
48324                 return 2;
48325               case 2: //vdst
48326                 return 2;
48327               default:
48328                 fatal("op idx %i out of bounds\n", opIdx);
48329                 return -1;
48330             }
48331         } // getOperandSize
48332
48333         bool
48334         isSrcOperand(int opIdx) override
48335         {
48336             switch (opIdx) {
48337               case 0: //src_0
48338                 return true;
48339               case 1: //src_1
48340                 return true;
48341               case 2: //vdst
48342                 return false;
48343               default:
48344                 fatal("op idx %i out of bounds\n", opIdx);
48345                 return false;
48346             }
48347         } // isSrcOperand
48348
48349         bool
48350         isDstOperand(int opIdx) override
48351         {
48352             switch (opIdx) {
48353               case 0: //src_0
48354                 return false;
48355               case 1: //src_1
48356                 return false;
48357               case 2: //vdst
48358                 return true;
48359               default:
48360                 fatal("op idx %i out of bounds\n", opIdx);
48361                 return false;
48362             }
48363         } // isDstOperand
48364
48365         void execute(GPUDynInstPtr) override;
48366     }; // Inst_VOP3__V_MAX_I16
48367
48368     class Inst_VOP3__V_MIN_U16 : public Inst_VOP3
48369     {
48370       public:
48371         Inst_VOP3__V_MIN_U16(InFmt_VOP3*);
48372         ~Inst_VOP3__V_MIN_U16();
48373
48374         int
48375         getNumOperands() override
48376         {
48377             return numDstRegOperands() + numSrcRegOperands();
48378         } // getNumOperands
48379
48380         int numDstRegOperands() override { return 1; }
48381         int numSrcRegOperands() override { return 2; }
48382
48383         int
48384         getOperandSize(int opIdx) override
48385         {
48386             switch (opIdx) {
48387               case 0: //src_0
48388                 return 2;
48389               case 1: //src_1
48390                 return 2;
48391               case 2: //vdst
48392                 return 2;
48393               default:
48394                 fatal("op idx %i out of bounds\n", opIdx);
48395                 return -1;
48396             }
48397         } // getOperandSize
48398
48399         bool
48400         isSrcOperand(int opIdx) override
48401         {
48402             switch (opIdx) {
48403               case 0: //src_0
48404                 return true;
48405               case 1: //src_1
48406                 return true;
48407               case 2: //vdst
48408                 return false;
48409               default:
48410                 fatal("op idx %i out of bounds\n", opIdx);
48411                 return false;
48412             }
48413         } // isSrcOperand
48414
48415         bool
48416         isDstOperand(int opIdx) override
48417         {
48418             switch (opIdx) {
48419               case 0: //src_0
48420                 return false;
48421               case 1: //src_1
48422                 return false;
48423               case 2: //vdst
48424                 return true;
48425               default:
48426                 fatal("op idx %i out of bounds\n", opIdx);
48427                 return false;
48428             }
48429         } // isDstOperand
48430
48431         void execute(GPUDynInstPtr) override;
48432     }; // Inst_VOP3__V_MIN_U16
48433
48434     class Inst_VOP3__V_MIN_I16 : public Inst_VOP3
48435     {
48436       public:
48437         Inst_VOP3__V_MIN_I16(InFmt_VOP3*);
48438         ~Inst_VOP3__V_MIN_I16();
48439
48440         int
48441         getNumOperands() override
48442         {
48443             return numDstRegOperands() + numSrcRegOperands();
48444         } // getNumOperands
48445
48446         int numDstRegOperands() override { return 1; }
48447         int numSrcRegOperands() override { return 2; }
48448
48449         int
48450         getOperandSize(int opIdx) override
48451         {
48452             switch (opIdx) {
48453               case 0: //src_0
48454                 return 2;
48455               case 1: //src_1
48456                 return 2;
48457               case 2: //vdst
48458                 return 2;
48459               default:
48460                 fatal("op idx %i out of bounds\n", opIdx);
48461                 return -1;
48462             }
48463         } // getOperandSize
48464
48465         bool
48466         isSrcOperand(int opIdx) override
48467         {
48468             switch (opIdx) {
48469               case 0: //src_0
48470                 return true;
48471               case 1: //src_1
48472                 return true;
48473               case 2: //vdst
48474                 return false;
48475               default:
48476                 fatal("op idx %i out of bounds\n", opIdx);
48477                 return false;
48478             }
48479         } // isSrcOperand
48480
48481         bool
48482         isDstOperand(int opIdx) override
48483         {
48484             switch (opIdx) {
48485               case 0: //src_0
48486                 return false;
48487               case 1: //src_1
48488                 return false;
48489               case 2: //vdst
48490                 return true;
48491               default:
48492                 fatal("op idx %i out of bounds\n", opIdx);
48493                 return false;
48494             }
48495         } // isDstOperand
48496
48497         void execute(GPUDynInstPtr) override;
48498     }; // Inst_VOP3__V_MIN_I16
48499
48500     class Inst_VOP3__V_LDEXP_F16 : public Inst_VOP3
48501     {
48502       public:
48503         Inst_VOP3__V_LDEXP_F16(InFmt_VOP3*);
48504         ~Inst_VOP3__V_LDEXP_F16();
48505
48506         int
48507         getNumOperands() override
48508         {
48509             return numDstRegOperands() + numSrcRegOperands();
48510         } // getNumOperands
48511
48512         int numDstRegOperands() override { return 1; }
48513         int numSrcRegOperands() override { return 2; }
48514
48515         int
48516         getOperandSize(int opIdx) override
48517         {
48518             switch (opIdx) {
48519               case 0: //src_0
48520                 return 2;
48521               case 1: //src_1
48522                 return 2;
48523               case 2: //vdst
48524                 return 2;
48525               default:
48526                 fatal("op idx %i out of bounds\n", opIdx);
48527                 return -1;
48528             }
48529         } // getOperandSize
48530
48531         bool
48532         isSrcOperand(int opIdx) override
48533         {
48534             switch (opIdx) {
48535               case 0: //src_0
48536                 return true;
48537               case 1: //src_1
48538                 return true;
48539               case 2: //vdst
48540                 return false;
48541               default:
48542                 fatal("op idx %i out of bounds\n", opIdx);
48543                 return false;
48544             }
48545         } // isSrcOperand
48546
48547         bool
48548         isDstOperand(int opIdx) override
48549         {
48550             switch (opIdx) {
48551               case 0: //src_0
48552                 return false;
48553               case 1: //src_1
48554                 return false;
48555               case 2: //vdst
48556                 return true;
48557               default:
48558                 fatal("op idx %i out of bounds\n", opIdx);
48559                 return false;
48560             }
48561         } // isDstOperand
48562
48563         void execute(GPUDynInstPtr) override;
48564     }; // Inst_VOP3__V_LDEXP_F16
48565
48566     class Inst_VOP3__V_NOP : public Inst_VOP3
48567     {
48568       public:
48569         Inst_VOP3__V_NOP(InFmt_VOP3*);
48570         ~Inst_VOP3__V_NOP();
48571
48572         int
48573         getNumOperands() override
48574         {
48575             return numDstRegOperands() + numSrcRegOperands();
48576         } // getNumOperands
48577
48578         int numDstRegOperands() override { return 0; }
48579         int numSrcRegOperands() override { return 0; }
48580
48581         int
48582         getOperandSize(int opIdx) override
48583         {
48584             switch (opIdx) {
48585               default:
48586                 fatal("op idx %i out of bounds\n", opIdx);
48587                 return -1;
48588             }
48589         } // getOperandSize
48590
48591         bool
48592         isSrcOperand(int opIdx) override
48593         {
48594             switch (opIdx) {
48595               default:
48596                 fatal("op idx %i out of bounds\n", opIdx);
48597                 return false;
48598             }
48599         } // isSrcOperand
48600
48601         bool
48602         isDstOperand(int opIdx) override
48603         {
48604             switch (opIdx) {
48605               default:
48606                 fatal("op idx %i out of bounds\n", opIdx);
48607                 return false;
48608             }
48609         } // isDstOperand
48610
48611         void execute(GPUDynInstPtr) override;
48612     }; // Inst_VOP3__V_NOP
48613
48614     class Inst_VOP3__V_MOV_B32 : public Inst_VOP3
48615     {
48616       public:
48617         Inst_VOP3__V_MOV_B32(InFmt_VOP3*);
48618         ~Inst_VOP3__V_MOV_B32();
48619
48620         int
48621         getNumOperands() override
48622         {
48623             return numDstRegOperands() + numSrcRegOperands();
48624         } // getNumOperands
48625
48626         int numDstRegOperands() override { return 1; }
48627         int numSrcRegOperands() override { return 1; }
48628
48629         int
48630         getOperandSize(int opIdx) override
48631         {
48632             switch (opIdx) {
48633               case 0: //src
48634                 return 4;
48635               case 1: //vdst
48636                 return 4;
48637               default:
48638                 fatal("op idx %i out of bounds\n", opIdx);
48639                 return -1;
48640             }
48641         } // getOperandSize
48642
48643         bool
48644         isSrcOperand(int opIdx) override
48645         {
48646             switch (opIdx) {
48647               case 0: //src
48648                 return true;
48649               case 1: //vdst
48650                 return false;
48651               default:
48652                 fatal("op idx %i out of bounds\n", opIdx);
48653                 return false;
48654             }
48655         } // isSrcOperand
48656
48657         bool
48658         isDstOperand(int opIdx) override
48659         {
48660             switch (opIdx) {
48661               case 0: //src
48662                 return false;
48663               case 1: //vdst
48664                 return true;
48665               default:
48666                 fatal("op idx %i out of bounds\n", opIdx);
48667                 return false;
48668             }
48669         } // isDstOperand
48670
48671         void execute(GPUDynInstPtr) override;
48672     }; // Inst_VOP3__V_MOV_B32
48673
48674     class Inst_VOP3__V_CVT_I32_F64 : public Inst_VOP3
48675     {
48676       public:
48677         Inst_VOP3__V_CVT_I32_F64(InFmt_VOP3*);
48678         ~Inst_VOP3__V_CVT_I32_F64();
48679
48680         int
48681         getNumOperands() override
48682         {
48683             return numDstRegOperands() + numSrcRegOperands();
48684         } // getNumOperands
48685
48686         int numDstRegOperands() override { return 1; }
48687         int numSrcRegOperands() override { return 1; }
48688
48689         int
48690         getOperandSize(int opIdx) override
48691         {
48692             switch (opIdx) {
48693               case 0: //src
48694                 return 8;
48695               case 1: //vdst
48696                 return 4;
48697               default:
48698                 fatal("op idx %i out of bounds\n", opIdx);
48699                 return -1;
48700             }
48701         } // getOperandSize
48702
48703         bool
48704         isSrcOperand(int opIdx) override
48705         {
48706             switch (opIdx) {
48707               case 0: //src
48708                 return true;
48709               case 1: //vdst
48710                 return false;
48711               default:
48712                 fatal("op idx %i out of bounds\n", opIdx);
48713                 return false;
48714             }
48715         } // isSrcOperand
48716
48717         bool
48718         isDstOperand(int opIdx) override
48719         {
48720             switch (opIdx) {
48721               case 0: //src
48722                 return false;
48723               case 1: //vdst
48724                 return true;
48725               default:
48726                 fatal("op idx %i out of bounds\n", opIdx);
48727                 return false;
48728             }
48729         } // isDstOperand
48730
48731         void execute(GPUDynInstPtr) override;
48732     }; // Inst_VOP3__V_CVT_I32_F64
48733
48734     class Inst_VOP3__V_CVT_F64_I32 : public Inst_VOP3
48735     {
48736       public:
48737         Inst_VOP3__V_CVT_F64_I32(InFmt_VOP3*);
48738         ~Inst_VOP3__V_CVT_F64_I32();
48739
48740         int
48741         getNumOperands() override
48742         {
48743             return numDstRegOperands() + numSrcRegOperands();
48744         } // getNumOperands
48745
48746         int numDstRegOperands() override { return 1; }
48747         int numSrcRegOperands() override { return 1; }
48748
48749         int
48750         getOperandSize(int opIdx) override
48751         {
48752             switch (opIdx) {
48753               case 0: //src
48754                 return 4;
48755               case 1: //vdst
48756                 return 8;
48757               default:
48758                 fatal("op idx %i out of bounds\n", opIdx);
48759                 return -1;
48760             }
48761         } // getOperandSize
48762
48763         bool
48764         isSrcOperand(int opIdx) override
48765         {
48766             switch (opIdx) {
48767               case 0: //src
48768                 return true;
48769               case 1: //vdst
48770                 return false;
48771               default:
48772                 fatal("op idx %i out of bounds\n", opIdx);
48773                 return false;
48774             }
48775         } // isSrcOperand
48776
48777         bool
48778         isDstOperand(int opIdx) override
48779         {
48780             switch (opIdx) {
48781               case 0: //src
48782                 return false;
48783               case 1: //vdst
48784                 return true;
48785               default:
48786                 fatal("op idx %i out of bounds\n", opIdx);
48787                 return false;
48788             }
48789         } // isDstOperand
48790
48791         void execute(GPUDynInstPtr) override;
48792     }; // Inst_VOP3__V_CVT_F64_I32
48793
48794     class Inst_VOP3__V_CVT_F32_I32 : public Inst_VOP3
48795     {
48796       public:
48797         Inst_VOP3__V_CVT_F32_I32(InFmt_VOP3*);
48798         ~Inst_VOP3__V_CVT_F32_I32();
48799
48800         int
48801         getNumOperands() override
48802         {
48803             return numDstRegOperands() + numSrcRegOperands();
48804         } // getNumOperands
48805
48806         int numDstRegOperands() override { return 1; }
48807         int numSrcRegOperands() override { return 1; }
48808
48809         int
48810         getOperandSize(int opIdx) override
48811         {
48812             switch (opIdx) {
48813               case 0: //src
48814                 return 4;
48815               case 1: //vdst
48816                 return 4;
48817               default:
48818                 fatal("op idx %i out of bounds\n", opIdx);
48819                 return -1;
48820             }
48821         } // getOperandSize
48822
48823         bool
48824         isSrcOperand(int opIdx) override
48825         {
48826             switch (opIdx) {
48827               case 0: //src
48828                 return true;
48829               case 1: //vdst
48830                 return false;
48831               default:
48832                 fatal("op idx %i out of bounds\n", opIdx);
48833                 return false;
48834             }
48835         } // isSrcOperand
48836
48837         bool
48838         isDstOperand(int opIdx) override
48839         {
48840             switch (opIdx) {
48841               case 0: //src
48842                 return false;
48843               case 1: //vdst
48844                 return true;
48845               default:
48846                 fatal("op idx %i out of bounds\n", opIdx);
48847                 return false;
48848             }
48849         } // isDstOperand
48850
48851         void execute(GPUDynInstPtr) override;
48852     }; // Inst_VOP3__V_CVT_F32_I32
48853
48854     class Inst_VOP3__V_CVT_F32_U32 : public Inst_VOP3
48855     {
48856       public:
48857         Inst_VOP3__V_CVT_F32_U32(InFmt_VOP3*);
48858         ~Inst_VOP3__V_CVT_F32_U32();
48859
48860         int
48861         getNumOperands() override
48862         {
48863             return numDstRegOperands() + numSrcRegOperands();
48864         } // getNumOperands
48865
48866         int numDstRegOperands() override { return 1; }
48867         int numSrcRegOperands() override { return 1; }
48868
48869         int
48870         getOperandSize(int opIdx) override
48871         {
48872             switch (opIdx) {
48873               case 0: //src
48874                 return 4;
48875               case 1: //vdst
48876                 return 4;
48877               default:
48878                 fatal("op idx %i out of bounds\n", opIdx);
48879                 return -1;
48880             }
48881         } // getOperandSize
48882
48883         bool
48884         isSrcOperand(int opIdx) override
48885         {
48886             switch (opIdx) {
48887               case 0: //src
48888                 return true;
48889               case 1: //vdst
48890                 return false;
48891               default:
48892                 fatal("op idx %i out of bounds\n", opIdx);
48893                 return false;
48894             }
48895         } // isSrcOperand
48896
48897         bool
48898         isDstOperand(int opIdx) override
48899         {
48900             switch (opIdx) {
48901               case 0: //src
48902                 return false;
48903               case 1: //vdst
48904                 return true;
48905               default:
48906                 fatal("op idx %i out of bounds\n", opIdx);
48907                 return false;
48908             }
48909         } // isDstOperand
48910
48911         void execute(GPUDynInstPtr) override;
48912     }; // Inst_VOP3__V_CVT_F32_U32
48913
48914     class Inst_VOP3__V_CVT_U32_F32 : public Inst_VOP3
48915     {
48916       public:
48917         Inst_VOP3__V_CVT_U32_F32(InFmt_VOP3*);
48918         ~Inst_VOP3__V_CVT_U32_F32();
48919
48920         int
48921         getNumOperands() override
48922         {
48923             return numDstRegOperands() + numSrcRegOperands();
48924         } // getNumOperands
48925
48926         int numDstRegOperands() override { return 1; }
48927         int numSrcRegOperands() override { return 1; }
48928
48929         int
48930         getOperandSize(int opIdx) override
48931         {
48932             switch (opIdx) {
48933               case 0: //src
48934                 return 4;
48935               case 1: //vdst
48936                 return 4;
48937               default:
48938                 fatal("op idx %i out of bounds\n", opIdx);
48939                 return -1;
48940             }
48941         } // getOperandSize
48942
48943         bool
48944         isSrcOperand(int opIdx) override
48945         {
48946             switch (opIdx) {
48947               case 0: //src
48948                 return true;
48949               case 1: //vdst
48950                 return false;
48951               default:
48952                 fatal("op idx %i out of bounds\n", opIdx);
48953                 return false;
48954             }
48955         } // isSrcOperand
48956
48957         bool
48958         isDstOperand(int opIdx) override
48959         {
48960             switch (opIdx) {
48961               case 0: //src
48962                 return false;
48963               case 1: //vdst
48964                 return true;
48965               default:
48966                 fatal("op idx %i out of bounds\n", opIdx);
48967                 return false;
48968             }
48969         } // isDstOperand
48970
48971         void execute(GPUDynInstPtr) override;
48972     }; // Inst_VOP3__V_CVT_U32_F32
48973
48974     class Inst_VOP3__V_CVT_I32_F32 : public Inst_VOP3
48975     {
48976       public:
48977         Inst_VOP3__V_CVT_I32_F32(InFmt_VOP3*);
48978         ~Inst_VOP3__V_CVT_I32_F32();
48979
48980         int
48981         getNumOperands() override
48982         {
48983             return numDstRegOperands() + numSrcRegOperands();
48984         } // getNumOperands
48985
48986         int numDstRegOperands() override { return 1; }
48987         int numSrcRegOperands() override { return 1; }
48988
48989         int
48990         getOperandSize(int opIdx) override
48991         {
48992             switch (opIdx) {
48993               case 0: //src
48994                 return 4;
48995               case 1: //vdst
48996                 return 4;
48997               default:
48998                 fatal("op idx %i out of bounds\n", opIdx);
48999                 return -1;
49000             }
49001         } // getOperandSize
49002
49003         bool
49004         isSrcOperand(int opIdx) override
49005         {
49006             switch (opIdx) {
49007               case 0: //src
49008                 return true;
49009               case 1: //vdst
49010                 return false;
49011               default:
49012                 fatal("op idx %i out of bounds\n", opIdx);
49013                 return false;
49014             }
49015         } // isSrcOperand
49016
49017         bool
49018         isDstOperand(int opIdx) override
49019         {
49020             switch (opIdx) {
49021               case 0: //src
49022                 return false;
49023               case 1: //vdst
49024                 return true;
49025               default:
49026                 fatal("op idx %i out of bounds\n", opIdx);
49027                 return false;
49028             }
49029         } // isDstOperand
49030
49031         void execute(GPUDynInstPtr) override;
49032     }; // Inst_VOP3__V_CVT_I32_F32
49033
49034     class Inst_VOP3__V_MOV_FED_B32 : public Inst_VOP3
49035     {
49036       public:
49037         Inst_VOP3__V_MOV_FED_B32(InFmt_VOP3*);
49038         ~Inst_VOP3__V_MOV_FED_B32();
49039
49040         int
49041         getNumOperands() override
49042         {
49043             return numDstRegOperands() + numSrcRegOperands();
49044         } // getNumOperands
49045
49046         int numDstRegOperands() override { return 1; }
49047         int numSrcRegOperands() override { return 1; }
49048
49049         int
49050         getOperandSize(int opIdx) override
49051         {
49052             switch (opIdx) {
49053               case 0: //src
49054                 return 4;
49055               case 1: //vdst
49056                 return 4;
49057               default:
49058                 fatal("op idx %i out of bounds\n", opIdx);
49059                 return -1;
49060             }
49061         } // getOperandSize
49062
49063         bool
49064         isSrcOperand(int opIdx) override
49065         {
49066             switch (opIdx) {
49067               case 0: //src
49068                 return true;
49069               case 1: //vdst
49070                 return false;
49071               default:
49072                 fatal("op idx %i out of bounds\n", opIdx);
49073                 return false;
49074             }
49075         } // isSrcOperand
49076
49077         bool
49078         isDstOperand(int opIdx) override
49079         {
49080             switch (opIdx) {
49081               case 0: //src
49082                 return false;
49083               case 1: //vdst
49084                 return true;
49085               default:
49086                 fatal("op idx %i out of bounds\n", opIdx);
49087                 return false;
49088             }
49089         } // isDstOperand
49090
49091         void execute(GPUDynInstPtr) override;
49092     }; // Inst_VOP3__V_MOV_FED_B32
49093
49094     class Inst_VOP3__V_CVT_F16_F32 : public Inst_VOP3
49095     {
49096       public:
49097         Inst_VOP3__V_CVT_F16_F32(InFmt_VOP3*);
49098         ~Inst_VOP3__V_CVT_F16_F32();
49099
49100         int
49101         getNumOperands() override
49102         {
49103             return numDstRegOperands() + numSrcRegOperands();
49104         } // getNumOperands
49105
49106         int numDstRegOperands() override { return 1; }
49107         int numSrcRegOperands() override { return 1; }
49108
49109         int
49110         getOperandSize(int opIdx) override
49111         {
49112             switch (opIdx) {
49113               case 0: //src
49114                 return 4;
49115               case 1: //vdst
49116                 return 2;
49117               default:
49118                 fatal("op idx %i out of bounds\n", opIdx);
49119                 return -1;
49120             }
49121         } // getOperandSize
49122
49123         bool
49124         isSrcOperand(int opIdx) override
49125         {
49126             switch (opIdx) {
49127               case 0: //src
49128                 return true;
49129               case 1: //vdst
49130                 return false;
49131               default:
49132                 fatal("op idx %i out of bounds\n", opIdx);
49133                 return false;
49134             }
49135         } // isSrcOperand
49136
49137         bool
49138         isDstOperand(int opIdx) override
49139         {
49140             switch (opIdx) {
49141               case 0: //src
49142                 return false;
49143               case 1: //vdst
49144                 return true;
49145               default:
49146                 fatal("op idx %i out of bounds\n", opIdx);
49147                 return false;
49148             }
49149         } // isDstOperand
49150
49151         void execute(GPUDynInstPtr) override;
49152     }; // Inst_VOP3__V_CVT_F16_F32
49153
49154     class Inst_VOP3__V_CVT_F32_F16 : public Inst_VOP3
49155     {
49156       public:
49157         Inst_VOP3__V_CVT_F32_F16(InFmt_VOP3*);
49158         ~Inst_VOP3__V_CVT_F32_F16();
49159
49160         int
49161         getNumOperands() override
49162         {
49163             return numDstRegOperands() + numSrcRegOperands();
49164         } // getNumOperands
49165
49166         int numDstRegOperands() override { return 1; }
49167         int numSrcRegOperands() override { return 1; }
49168
49169         int
49170         getOperandSize(int opIdx) override
49171         {
49172             switch (opIdx) {
49173               case 0: //src
49174                 return 2;
49175               case 1: //vdst
49176                 return 4;
49177               default:
49178                 fatal("op idx %i out of bounds\n", opIdx);
49179                 return -1;
49180             }
49181         } // getOperandSize
49182
49183         bool
49184         isSrcOperand(int opIdx) override
49185         {
49186             switch (opIdx) {
49187               case 0: //src
49188                 return true;
49189               case 1: //vdst
49190                 return false;
49191               default:
49192                 fatal("op idx %i out of bounds\n", opIdx);
49193                 return false;
49194             }
49195         } // isSrcOperand
49196
49197         bool
49198         isDstOperand(int opIdx) override
49199         {
49200             switch (opIdx) {
49201               case 0: //src
49202                 return false;
49203               case 1: //vdst
49204                 return true;
49205               default:
49206                 fatal("op idx %i out of bounds\n", opIdx);
49207                 return false;
49208             }
49209         } // isDstOperand
49210
49211         void execute(GPUDynInstPtr) override;
49212     }; // Inst_VOP3__V_CVT_F32_F16
49213
49214     class Inst_VOP3__V_CVT_RPI_I32_F32 : public Inst_VOP3
49215     {
49216       public:
49217         Inst_VOP3__V_CVT_RPI_I32_F32(InFmt_VOP3*);
49218         ~Inst_VOP3__V_CVT_RPI_I32_F32();
49219
49220         int
49221         getNumOperands() override
49222         {
49223             return numDstRegOperands() + numSrcRegOperands();
49224         } // getNumOperands
49225
49226         int numDstRegOperands() override { return 1; }
49227         int numSrcRegOperands() override { return 1; }
49228
49229         int
49230         getOperandSize(int opIdx) override
49231         {
49232             switch (opIdx) {
49233               case 0: //src
49234                 return 4;
49235               case 1: //vdst
49236                 return 4;
49237               default:
49238                 fatal("op idx %i out of bounds\n", opIdx);
49239                 return -1;
49240             }
49241         } // getOperandSize
49242
49243         bool
49244         isSrcOperand(int opIdx) override
49245         {
49246             switch (opIdx) {
49247               case 0: //src
49248                 return true;
49249               case 1: //vdst
49250                 return false;
49251               default:
49252                 fatal("op idx %i out of bounds\n", opIdx);
49253                 return false;
49254             }
49255         } // isSrcOperand
49256
49257         bool
49258         isDstOperand(int opIdx) override
49259         {
49260             switch (opIdx) {
49261               case 0: //src
49262                 return false;
49263               case 1: //vdst
49264                 return true;
49265               default:
49266                 fatal("op idx %i out of bounds\n", opIdx);
49267                 return false;
49268             }
49269         } // isDstOperand
49270
49271         void execute(GPUDynInstPtr) override;
49272     }; // Inst_VOP3__V_CVT_RPI_I32_F32
49273
49274     class Inst_VOP3__V_CVT_FLR_I32_F32 : public Inst_VOP3
49275     {
49276       public:
49277         Inst_VOP3__V_CVT_FLR_I32_F32(InFmt_VOP3*);
49278         ~Inst_VOP3__V_CVT_FLR_I32_F32();
49279
49280         int
49281         getNumOperands() override
49282         {
49283             return numDstRegOperands() + numSrcRegOperands();
49284         } // getNumOperands
49285
49286         int numDstRegOperands() override { return 1; }
49287         int numSrcRegOperands() override { return 1; }
49288
49289         int
49290         getOperandSize(int opIdx) override
49291         {
49292             switch (opIdx) {
49293               case 0: //src
49294                 return 4;
49295               case 1: //vdst
49296                 return 4;
49297               default:
49298                 fatal("op idx %i out of bounds\n", opIdx);
49299                 return -1;
49300             }
49301         } // getOperandSize
49302
49303         bool
49304         isSrcOperand(int opIdx) override
49305         {
49306             switch (opIdx) {
49307               case 0: //src
49308                 return true;
49309               case 1: //vdst
49310                 return false;
49311               default:
49312                 fatal("op idx %i out of bounds\n", opIdx);
49313                 return false;
49314             }
49315         } // isSrcOperand
49316
49317         bool
49318         isDstOperand(int opIdx) override
49319         {
49320             switch (opIdx) {
49321               case 0: //src
49322                 return false;
49323               case 1: //vdst
49324                 return true;
49325               default:
49326                 fatal("op idx %i out of bounds\n", opIdx);
49327                 return false;
49328             }
49329         } // isDstOperand
49330
49331         void execute(GPUDynInstPtr) override;
49332     }; // Inst_VOP3__V_CVT_FLR_I32_F32
49333
49334     class Inst_VOP3__V_CVT_OFF_F32_I4 : public Inst_VOP3
49335     {
49336       public:
49337         Inst_VOP3__V_CVT_OFF_F32_I4(InFmt_VOP3*);
49338         ~Inst_VOP3__V_CVT_OFF_F32_I4();
49339
49340         int
49341         getNumOperands() override
49342         {
49343             return numDstRegOperands() + numSrcRegOperands();
49344         } // getNumOperands
49345
49346         int numDstRegOperands() override { return 1; }
49347         int numSrcRegOperands() override { return 1; }
49348
49349         int
49350         getOperandSize(int opIdx) override
49351         {
49352             switch (opIdx) {
49353               case 0: //src
49354                 return 4;
49355               case 1: //vdst
49356                 return 4;
49357               default:
49358                 fatal("op idx %i out of bounds\n", opIdx);
49359                 return -1;
49360             }
49361         } // getOperandSize
49362
49363         bool
49364         isSrcOperand(int opIdx) override
49365         {
49366             switch (opIdx) {
49367               case 0: //src
49368                 return true;
49369               case 1: //vdst
49370                 return false;
49371               default:
49372                 fatal("op idx %i out of bounds\n", opIdx);
49373                 return false;
49374             }
49375         } // isSrcOperand
49376
49377         bool
49378         isDstOperand(int opIdx) override
49379         {
49380             switch (opIdx) {
49381               case 0: //src
49382                 return false;
49383               case 1: //vdst
49384                 return true;
49385               default:
49386                 fatal("op idx %i out of bounds\n", opIdx);
49387                 return false;
49388             }
49389         } // isDstOperand
49390
49391         void execute(GPUDynInstPtr) override;
49392     }; // Inst_VOP3__V_CVT_OFF_F32_I4
49393
49394     class Inst_VOP3__V_CVT_F32_F64 : public Inst_VOP3
49395     {
49396       public:
49397         Inst_VOP3__V_CVT_F32_F64(InFmt_VOP3*);
49398         ~Inst_VOP3__V_CVT_F32_F64();
49399
49400         int
49401         getNumOperands() override
49402         {
49403             return numDstRegOperands() + numSrcRegOperands();
49404         } // getNumOperands
49405
49406         int numDstRegOperands() override { return 1; }
49407         int numSrcRegOperands() override { return 1; }
49408
49409         int
49410         getOperandSize(int opIdx) override
49411         {
49412             switch (opIdx) {
49413               case 0: //src
49414                 return 8;
49415               case 1: //vdst
49416                 return 4;
49417               default:
49418                 fatal("op idx %i out of bounds\n", opIdx);
49419                 return -1;
49420             }
49421         } // getOperandSize
49422
49423         bool
49424         isSrcOperand(int opIdx) override
49425         {
49426             switch (opIdx) {
49427               case 0: //src
49428                 return true;
49429               case 1: //vdst
49430                 return false;
49431               default:
49432                 fatal("op idx %i out of bounds\n", opIdx);
49433                 return false;
49434             }
49435         } // isSrcOperand
49436
49437         bool
49438         isDstOperand(int opIdx) override
49439         {
49440             switch (opIdx) {
49441               case 0: //src
49442                 return false;
49443               case 1: //vdst
49444                 return true;
49445               default:
49446                 fatal("op idx %i out of bounds\n", opIdx);
49447                 return false;
49448             }
49449         } // isDstOperand
49450
49451         void execute(GPUDynInstPtr) override;
49452     }; // Inst_VOP3__V_CVT_F32_F64
49453
49454     class Inst_VOP3__V_CVT_F64_F32 : public Inst_VOP3
49455     {
49456       public:
49457         Inst_VOP3__V_CVT_F64_F32(InFmt_VOP3*);
49458         ~Inst_VOP3__V_CVT_F64_F32();
49459
49460         int
49461         getNumOperands() override
49462         {
49463             return numDstRegOperands() + numSrcRegOperands();
49464         } // getNumOperands
49465
49466         int numDstRegOperands() override { return 1; }
49467         int numSrcRegOperands() override { return 1; }
49468
49469         int
49470         getOperandSize(int opIdx) override
49471         {
49472             switch (opIdx) {
49473               case 0: //src
49474                 return 4;
49475               case 1: //vdst
49476                 return 8;
49477               default:
49478                 fatal("op idx %i out of bounds\n", opIdx);
49479                 return -1;
49480             }
49481         } // getOperandSize
49482
49483         bool
49484         isSrcOperand(int opIdx) override
49485         {
49486             switch (opIdx) {
49487               case 0: //src
49488                 return true;
49489               case 1: //vdst
49490                 return false;
49491               default:
49492                 fatal("op idx %i out of bounds\n", opIdx);
49493                 return false;
49494             }
49495         } // isSrcOperand
49496
49497         bool
49498         isDstOperand(int opIdx) override
49499         {
49500             switch (opIdx) {
49501               case 0: //src
49502                 return false;
49503               case 1: //vdst
49504                 return true;
49505               default:
49506                 fatal("op idx %i out of bounds\n", opIdx);
49507                 return false;
49508             }
49509         } // isDstOperand
49510
49511         void execute(GPUDynInstPtr) override;
49512     }; // Inst_VOP3__V_CVT_F64_F32
49513
49514     class Inst_VOP3__V_CVT_F32_UBYTE0 : public Inst_VOP3
49515     {
49516       public:
49517         Inst_VOP3__V_CVT_F32_UBYTE0(InFmt_VOP3*);
49518         ~Inst_VOP3__V_CVT_F32_UBYTE0();
49519
49520         int
49521         getNumOperands() override
49522         {
49523             return numDstRegOperands() + numSrcRegOperands();
49524         } // getNumOperands
49525
49526         int numDstRegOperands() override { return 1; }
49527         int numSrcRegOperands() override { return 1; }
49528
49529         int
49530         getOperandSize(int opIdx) override
49531         {
49532             switch (opIdx) {
49533               case 0: //src
49534                 return 4;
49535               case 1: //vdst
49536                 return 4;
49537               default:
49538                 fatal("op idx %i out of bounds\n", opIdx);
49539                 return -1;
49540             }
49541         } // getOperandSize
49542
49543         bool
49544         isSrcOperand(int opIdx) override
49545         {
49546             switch (opIdx) {
49547               case 0: //src
49548                 return true;
49549               case 1: //vdst
49550                 return false;
49551               default:
49552                 fatal("op idx %i out of bounds\n", opIdx);
49553                 return false;
49554             }
49555         } // isSrcOperand
49556
49557         bool
49558         isDstOperand(int opIdx) override
49559         {
49560             switch (opIdx) {
49561               case 0: //src
49562                 return false;
49563               case 1: //vdst
49564                 return true;
49565               default:
49566                 fatal("op idx %i out of bounds\n", opIdx);
49567                 return false;
49568             }
49569         } // isDstOperand
49570
49571         void execute(GPUDynInstPtr) override;
49572     }; // Inst_VOP3__V_CVT_F32_UBYTE0
49573
49574     class Inst_VOP3__V_CVT_F32_UBYTE1 : public Inst_VOP3
49575     {
49576       public:
49577         Inst_VOP3__V_CVT_F32_UBYTE1(InFmt_VOP3*);
49578         ~Inst_VOP3__V_CVT_F32_UBYTE1();
49579
49580         int
49581         getNumOperands() override
49582         {
49583             return numDstRegOperands() + numSrcRegOperands();
49584         } // getNumOperands
49585
49586         int numDstRegOperands() override { return 1; }
49587         int numSrcRegOperands() override { return 1; }
49588
49589         int
49590         getOperandSize(int opIdx) override
49591         {
49592             switch (opIdx) {
49593               case 0: //src
49594                 return 4;
49595               case 1: //vdst
49596                 return 4;
49597               default:
49598                 fatal("op idx %i out of bounds\n", opIdx);
49599                 return -1;
49600             }
49601         } // getOperandSize
49602
49603         bool
49604         isSrcOperand(int opIdx) override
49605         {
49606             switch (opIdx) {
49607               case 0: //src
49608                 return true;
49609               case 1: //vdst
49610                 return false;
49611               default:
49612                 fatal("op idx %i out of bounds\n", opIdx);
49613                 return false;
49614             }
49615         } // isSrcOperand
49616
49617         bool
49618         isDstOperand(int opIdx) override
49619         {
49620             switch (opIdx) {
49621               case 0: //src
49622                 return false;
49623               case 1: //vdst
49624                 return true;
49625               default:
49626                 fatal("op idx %i out of bounds\n", opIdx);
49627                 return false;
49628             }
49629         } // isDstOperand
49630
49631         void execute(GPUDynInstPtr) override;
49632     }; // Inst_VOP3__V_CVT_F32_UBYTE1
49633
49634     class Inst_VOP3__V_CVT_F32_UBYTE2 : public Inst_VOP3
49635     {
49636       public:
49637         Inst_VOP3__V_CVT_F32_UBYTE2(InFmt_VOP3*);
49638         ~Inst_VOP3__V_CVT_F32_UBYTE2();
49639
49640         int
49641         getNumOperands() override
49642         {
49643             return numDstRegOperands() + numSrcRegOperands();
49644         } // getNumOperands
49645
49646         int numDstRegOperands() override { return 1; }
49647         int numSrcRegOperands() override { return 1; }
49648
49649         int
49650         getOperandSize(int opIdx) override
49651         {
49652             switch (opIdx) {
49653               case 0: //src
49654                 return 4;
49655               case 1: //vdst
49656                 return 4;
49657               default:
49658                 fatal("op idx %i out of bounds\n", opIdx);
49659                 return -1;
49660             }
49661         } // getOperandSize
49662
49663         bool
49664         isSrcOperand(int opIdx) override
49665         {
49666             switch (opIdx) {
49667               case 0: //src
49668                 return true;
49669               case 1: //vdst
49670                 return false;
49671               default:
49672                 fatal("op idx %i out of bounds\n", opIdx);
49673                 return false;
49674             }
49675         } // isSrcOperand
49676
49677         bool
49678         isDstOperand(int opIdx) override
49679         {
49680             switch (opIdx) {
49681               case 0: //src
49682                 return false;
49683               case 1: //vdst
49684                 return true;
49685               default:
49686                 fatal("op idx %i out of bounds\n", opIdx);
49687                 return false;
49688             }
49689         } // isDstOperand
49690
49691         void execute(GPUDynInstPtr) override;
49692     }; // Inst_VOP3__V_CVT_F32_UBYTE2
49693
49694     class Inst_VOP3__V_CVT_F32_UBYTE3 : public Inst_VOP3
49695     {
49696       public:
49697         Inst_VOP3__V_CVT_F32_UBYTE3(InFmt_VOP3*);
49698         ~Inst_VOP3__V_CVT_F32_UBYTE3();
49699
49700         int
49701         getNumOperands() override
49702         {
49703             return numDstRegOperands() + numSrcRegOperands();
49704         } // getNumOperands
49705
49706         int numDstRegOperands() override { return 1; }
49707         int numSrcRegOperands() override { return 1; }
49708
49709         int
49710         getOperandSize(int opIdx) override
49711         {
49712             switch (opIdx) {
49713               case 0: //src
49714                 return 4;
49715               case 1: //vdst
49716                 return 4;
49717               default:
49718                 fatal("op idx %i out of bounds\n", opIdx);
49719                 return -1;
49720             }
49721         } // getOperandSize
49722
49723         bool
49724         isSrcOperand(int opIdx) override
49725         {
49726             switch (opIdx) {
49727               case 0: //src
49728                 return true;
49729               case 1: //vdst
49730                 return false;
49731               default:
49732                 fatal("op idx %i out of bounds\n", opIdx);
49733                 return false;
49734             }
49735         } // isSrcOperand
49736
49737         bool
49738         isDstOperand(int opIdx) override
49739         {
49740             switch (opIdx) {
49741               case 0: //src
49742                 return false;
49743               case 1: //vdst
49744                 return true;
49745               default:
49746                 fatal("op idx %i out of bounds\n", opIdx);
49747                 return false;
49748             }
49749         } // isDstOperand
49750
49751         void execute(GPUDynInstPtr) override;
49752     }; // Inst_VOP3__V_CVT_F32_UBYTE3
49753
49754     class Inst_VOP3__V_CVT_U32_F64 : public Inst_VOP3
49755     {
49756       public:
49757         Inst_VOP3__V_CVT_U32_F64(InFmt_VOP3*);
49758         ~Inst_VOP3__V_CVT_U32_F64();
49759
49760         int
49761         getNumOperands() override
49762         {
49763             return numDstRegOperands() + numSrcRegOperands();
49764         } // getNumOperands
49765
49766         int numDstRegOperands() override { return 1; }
49767         int numSrcRegOperands() override { return 1; }
49768
49769         int
49770         getOperandSize(int opIdx) override
49771         {
49772             switch (opIdx) {
49773               case 0: //src
49774                 return 8;
49775               case 1: //vdst
49776                 return 4;
49777               default:
49778                 fatal("op idx %i out of bounds\n", opIdx);
49779                 return -1;
49780             }
49781         } // getOperandSize
49782
49783         bool
49784         isSrcOperand(int opIdx) override
49785         {
49786             switch (opIdx) {
49787               case 0: //src
49788                 return true;
49789               case 1: //vdst
49790                 return false;
49791               default:
49792                 fatal("op idx %i out of bounds\n", opIdx);
49793                 return false;
49794             }
49795         } // isSrcOperand
49796
49797         bool
49798         isDstOperand(int opIdx) override
49799         {
49800             switch (opIdx) {
49801               case 0: //src
49802                 return false;
49803               case 1: //vdst
49804                 return true;
49805               default:
49806                 fatal("op idx %i out of bounds\n", opIdx);
49807                 return false;
49808             }
49809         } // isDstOperand
49810
49811         void execute(GPUDynInstPtr) override;
49812     }; // Inst_VOP3__V_CVT_U32_F64
49813
49814     class Inst_VOP3__V_CVT_F64_U32 : public Inst_VOP3
49815     {
49816       public:
49817         Inst_VOP3__V_CVT_F64_U32(InFmt_VOP3*);
49818         ~Inst_VOP3__V_CVT_F64_U32();
49819
49820         int
49821         getNumOperands() override
49822         {
49823             return numDstRegOperands() + numSrcRegOperands();
49824         } // getNumOperands
49825
49826         int numDstRegOperands() override { return 1; }
49827         int numSrcRegOperands() override { return 1; }
49828
49829         int
49830         getOperandSize(int opIdx) override
49831         {
49832             switch (opIdx) {
49833               case 0: //src
49834                 return 4;
49835               case 1: //vdst
49836                 return 8;
49837               default:
49838                 fatal("op idx %i out of bounds\n", opIdx);
49839                 return -1;
49840             }
49841         } // getOperandSize
49842
49843         bool
49844         isSrcOperand(int opIdx) override
49845         {
49846             switch (opIdx) {
49847               case 0: //src
49848                 return true;
49849               case 1: //vdst
49850                 return false;
49851               default:
49852                 fatal("op idx %i out of bounds\n", opIdx);
49853                 return false;
49854             }
49855         } // isSrcOperand
49856
49857         bool
49858         isDstOperand(int opIdx) override
49859         {
49860             switch (opIdx) {
49861               case 0: //src
49862                 return false;
49863               case 1: //vdst
49864                 return true;
49865               default:
49866                 fatal("op idx %i out of bounds\n", opIdx);
49867                 return false;
49868             }
49869         } // isDstOperand
49870
49871         void execute(GPUDynInstPtr) override;
49872     }; // Inst_VOP3__V_CVT_F64_U32
49873
49874     class Inst_VOP3__V_TRUNC_F64 : public Inst_VOP3
49875     {
49876       public:
49877         Inst_VOP3__V_TRUNC_F64(InFmt_VOP3*);
49878         ~Inst_VOP3__V_TRUNC_F64();
49879
49880         int
49881         getNumOperands() override
49882         {
49883             return numDstRegOperands() + numSrcRegOperands();
49884         } // getNumOperands
49885
49886         int numDstRegOperands() override { return 1; }
49887         int numSrcRegOperands() override { return 1; }
49888
49889         int
49890         getOperandSize(int opIdx) override
49891         {
49892             switch (opIdx) {
49893               case 0: //src
49894                 return 8;
49895               case 1: //vdst
49896                 return 8;
49897               default:
49898                 fatal("op idx %i out of bounds\n", opIdx);
49899                 return -1;
49900             }
49901         } // getOperandSize
49902
49903         bool
49904         isSrcOperand(int opIdx) override
49905         {
49906             switch (opIdx) {
49907               case 0: //src
49908                 return true;
49909               case 1: //vdst
49910                 return false;
49911               default:
49912                 fatal("op idx %i out of bounds\n", opIdx);
49913                 return false;
49914             }
49915         } // isSrcOperand
49916
49917         bool
49918         isDstOperand(int opIdx) override
49919         {
49920             switch (opIdx) {
49921               case 0: //src
49922                 return false;
49923               case 1: //vdst
49924                 return true;
49925               default:
49926                 fatal("op idx %i out of bounds\n", opIdx);
49927                 return false;
49928             }
49929         } // isDstOperand
49930
49931         void execute(GPUDynInstPtr) override;
49932     }; // Inst_VOP3__V_TRUNC_F64
49933
49934     class Inst_VOP3__V_CEIL_F64 : public Inst_VOP3
49935     {
49936       public:
49937         Inst_VOP3__V_CEIL_F64(InFmt_VOP3*);
49938         ~Inst_VOP3__V_CEIL_F64();
49939
49940         int
49941         getNumOperands() override
49942         {
49943             return numDstRegOperands() + numSrcRegOperands();
49944         } // getNumOperands
49945
49946         int numDstRegOperands() override { return 1; }
49947         int numSrcRegOperands() override { return 1; }
49948
49949         int
49950         getOperandSize(int opIdx) override
49951         {
49952             switch (opIdx) {
49953               case 0: //src
49954                 return 8;
49955               case 1: //vdst
49956                 return 8;
49957               default:
49958                 fatal("op idx %i out of bounds\n", opIdx);
49959                 return -1;
49960             }
49961         } // getOperandSize
49962
49963         bool
49964         isSrcOperand(int opIdx) override
49965         {
49966             switch (opIdx) {
49967               case 0: //src
49968                 return true;
49969               case 1: //vdst
49970                 return false;
49971               default:
49972                 fatal("op idx %i out of bounds\n", opIdx);
49973                 return false;
49974             }
49975         } // isSrcOperand
49976
49977         bool
49978         isDstOperand(int opIdx) override
49979         {
49980             switch (opIdx) {
49981               case 0: //src
49982                 return false;
49983               case 1: //vdst
49984                 return true;
49985               default:
49986                 fatal("op idx %i out of bounds\n", opIdx);
49987                 return false;
49988             }
49989         } // isDstOperand
49990
49991         void execute(GPUDynInstPtr) override;
49992     }; // Inst_VOP3__V_CEIL_F64
49993
49994     class Inst_VOP3__V_RNDNE_F64 : public Inst_VOP3
49995     {
49996       public:
49997         Inst_VOP3__V_RNDNE_F64(InFmt_VOP3*);
49998         ~Inst_VOP3__V_RNDNE_F64();
49999
50000         int
50001         getNumOperands() override
50002         {
50003             return numDstRegOperands() + numSrcRegOperands();
50004         } // getNumOperands
50005
50006         int numDstRegOperands() override { return 1; }
50007         int numSrcRegOperands() override { return 1; }
50008
50009         int
50010         getOperandSize(int opIdx) override
50011         {
50012             switch (opIdx) {
50013               case 0: //src
50014                 return 8;
50015               case 1: //vdst
50016                 return 8;
50017               default:
50018                 fatal("op idx %i out of bounds\n", opIdx);
50019                 return -1;
50020             }
50021         } // getOperandSize
50022
50023         bool
50024         isSrcOperand(int opIdx) override
50025         {
50026             switch (opIdx) {
50027               case 0: //src
50028                 return true;
50029               case 1: //vdst
50030                 return false;
50031               default:
50032                 fatal("op idx %i out of bounds\n", opIdx);
50033                 return false;
50034             }
50035         } // isSrcOperand
50036
50037         bool
50038         isDstOperand(int opIdx) override
50039         {
50040             switch (opIdx) {
50041               case 0: //src
50042                 return false;
50043               case 1: //vdst
50044                 return true;
50045               default:
50046                 fatal("op idx %i out of bounds\n", opIdx);
50047                 return false;
50048             }
50049         } // isDstOperand
50050
50051         void execute(GPUDynInstPtr) override;
50052     }; // Inst_VOP3__V_RNDNE_F64
50053
50054     class Inst_VOP3__V_FLOOR_F64 : public Inst_VOP3
50055     {
50056       public:
50057         Inst_VOP3__V_FLOOR_F64(InFmt_VOP3*);
50058         ~Inst_VOP3__V_FLOOR_F64();
50059
50060         int
50061         getNumOperands() override
50062         {
50063             return numDstRegOperands() + numSrcRegOperands();
50064         } // getNumOperands
50065
50066         int numDstRegOperands() override { return 1; }
50067         int numSrcRegOperands() override { return 1; }
50068
50069         int
50070         getOperandSize(int opIdx) override
50071         {
50072             switch (opIdx) {
50073               case 0: //src
50074                 return 8;
50075               case 1: //vdst
50076                 return 8;
50077               default:
50078                 fatal("op idx %i out of bounds\n", opIdx);
50079                 return -1;
50080             }
50081         } // getOperandSize
50082
50083         bool
50084         isSrcOperand(int opIdx) override
50085         {
50086             switch (opIdx) {
50087               case 0: //src
50088                 return true;
50089               case 1: //vdst
50090                 return false;
50091               default:
50092                 fatal("op idx %i out of bounds\n", opIdx);
50093                 return false;
50094             }
50095         } // isSrcOperand
50096
50097         bool
50098         isDstOperand(int opIdx) override
50099         {
50100             switch (opIdx) {
50101               case 0: //src
50102                 return false;
50103               case 1: //vdst
50104                 return true;
50105               default:
50106                 fatal("op idx %i out of bounds\n", opIdx);
50107                 return false;
50108             }
50109         } // isDstOperand
50110
50111         void execute(GPUDynInstPtr) override;
50112     }; // Inst_VOP3__V_FLOOR_F64
50113
50114     class Inst_VOP3__V_FRACT_F32 : public Inst_VOP3
50115     {
50116       public:
50117         Inst_VOP3__V_FRACT_F32(InFmt_VOP3*);
50118         ~Inst_VOP3__V_FRACT_F32();
50119
50120         int
50121         getNumOperands() override
50122         {
50123             return numDstRegOperands() + numSrcRegOperands();
50124         } // getNumOperands
50125
50126         int numDstRegOperands() override { return 1; }
50127         int numSrcRegOperands() override { return 1; }
50128
50129         int
50130         getOperandSize(int opIdx) override
50131         {
50132             switch (opIdx) {
50133               case 0: //src
50134                 return 4;
50135               case 1: //vdst
50136                 return 4;
50137               default:
50138                 fatal("op idx %i out of bounds\n", opIdx);
50139                 return -1;
50140             }
50141         } // getOperandSize
50142
50143         bool
50144         isSrcOperand(int opIdx) override
50145         {
50146             switch (opIdx) {
50147               case 0: //src
50148                 return true;
50149               case 1: //vdst
50150                 return false;
50151               default:
50152                 fatal("op idx %i out of bounds\n", opIdx);
50153                 return false;
50154             }
50155         } // isSrcOperand
50156
50157         bool
50158         isDstOperand(int opIdx) override
50159         {
50160             switch (opIdx) {
50161               case 0: //src
50162                 return false;
50163               case 1: //vdst
50164                 return true;
50165               default:
50166                 fatal("op idx %i out of bounds\n", opIdx);
50167                 return false;
50168             }
50169         } // isDstOperand
50170
50171         void execute(GPUDynInstPtr) override;
50172     }; // Inst_VOP3__V_FRACT_F32
50173
50174     class Inst_VOP3__V_TRUNC_F32 : public Inst_VOP3
50175     {
50176       public:
50177         Inst_VOP3__V_TRUNC_F32(InFmt_VOP3*);
50178         ~Inst_VOP3__V_TRUNC_F32();
50179
50180         int
50181         getNumOperands() override
50182         {
50183             return numDstRegOperands() + numSrcRegOperands();
50184         } // getNumOperands
50185
50186         int numDstRegOperands() override { return 1; }
50187         int numSrcRegOperands() override { return 1; }
50188
50189         int
50190         getOperandSize(int opIdx) override
50191         {
50192             switch (opIdx) {
50193               case 0: //src
50194                 return 4;
50195               case 1: //vdst
50196                 return 4;
50197               default:
50198                 fatal("op idx %i out of bounds\n", opIdx);
50199                 return -1;
50200             }
50201         } // getOperandSize
50202
50203         bool
50204         isSrcOperand(int opIdx) override
50205         {
50206             switch (opIdx) {
50207               case 0: //src
50208                 return true;
50209               case 1: //vdst
50210                 return false;
50211               default:
50212                 fatal("op idx %i out of bounds\n", opIdx);
50213                 return false;
50214             }
50215         } // isSrcOperand
50216
50217         bool
50218         isDstOperand(int opIdx) override
50219         {
50220             switch (opIdx) {
50221               case 0: //src
50222                 return false;
50223               case 1: //vdst
50224                 return true;
50225               default:
50226                 fatal("op idx %i out of bounds\n", opIdx);
50227                 return false;
50228             }
50229         } // isDstOperand
50230
50231         void execute(GPUDynInstPtr) override;
50232     }; // Inst_VOP3__V_TRUNC_F32
50233
50234     class Inst_VOP3__V_CEIL_F32 : public Inst_VOP3
50235     {
50236       public:
50237         Inst_VOP3__V_CEIL_F32(InFmt_VOP3*);
50238         ~Inst_VOP3__V_CEIL_F32();
50239
50240         int
50241         getNumOperands() override
50242         {
50243             return numDstRegOperands() + numSrcRegOperands();
50244         } // getNumOperands
50245
50246         int numDstRegOperands() override { return 1; }
50247         int numSrcRegOperands() override { return 1; }
50248
50249         int
50250         getOperandSize(int opIdx) override
50251         {
50252             switch (opIdx) {
50253               case 0: //src
50254                 return 4;
50255               case 1: //vdst
50256                 return 4;
50257               default:
50258                 fatal("op idx %i out of bounds\n", opIdx);
50259                 return -1;
50260             }
50261         } // getOperandSize
50262
50263         bool
50264         isSrcOperand(int opIdx) override
50265         {
50266             switch (opIdx) {
50267               case 0: //src
50268                 return true;
50269               case 1: //vdst
50270                 return false;
50271               default:
50272                 fatal("op idx %i out of bounds\n", opIdx);
50273                 return false;
50274             }
50275         } // isSrcOperand
50276
50277         bool
50278         isDstOperand(int opIdx) override
50279         {
50280             switch (opIdx) {
50281               case 0: //src
50282                 return false;
50283               case 1: //vdst
50284                 return true;
50285               default:
50286                 fatal("op idx %i out of bounds\n", opIdx);
50287                 return false;
50288             }
50289         } // isDstOperand
50290
50291         void execute(GPUDynInstPtr) override;
50292     }; // Inst_VOP3__V_CEIL_F32
50293
50294     class Inst_VOP3__V_RNDNE_F32 : public Inst_VOP3
50295     {
50296       public:
50297         Inst_VOP3__V_RNDNE_F32(InFmt_VOP3*);
50298         ~Inst_VOP3__V_RNDNE_F32();
50299
50300         int
50301         getNumOperands() override
50302         {
50303             return numDstRegOperands() + numSrcRegOperands();
50304         } // getNumOperands
50305
50306         int numDstRegOperands() override { return 1; }
50307         int numSrcRegOperands() override { return 1; }
50308
50309         int
50310         getOperandSize(int opIdx) override
50311         {
50312             switch (opIdx) {
50313               case 0: //src
50314                 return 4;
50315               case 1: //vdst
50316                 return 4;
50317               default:
50318                 fatal("op idx %i out of bounds\n", opIdx);
50319                 return -1;
50320             }
50321         } // getOperandSize
50322
50323         bool
50324         isSrcOperand(int opIdx) override
50325         {
50326             switch (opIdx) {
50327               case 0: //src
50328                 return true;
50329               case 1: //vdst
50330                 return false;
50331               default:
50332                 fatal("op idx %i out of bounds\n", opIdx);
50333                 return false;
50334             }
50335         } // isSrcOperand
50336
50337         bool
50338         isDstOperand(int opIdx) override
50339         {
50340             switch (opIdx) {
50341               case 0: //src
50342                 return false;
50343               case 1: //vdst
50344                 return true;
50345               default:
50346                 fatal("op idx %i out of bounds\n", opIdx);
50347                 return false;
50348             }
50349         } // isDstOperand
50350
50351         void execute(GPUDynInstPtr) override;
50352     }; // Inst_VOP3__V_RNDNE_F32
50353
50354     class Inst_VOP3__V_FLOOR_F32 : public Inst_VOP3
50355     {
50356       public:
50357         Inst_VOP3__V_FLOOR_F32(InFmt_VOP3*);
50358         ~Inst_VOP3__V_FLOOR_F32();
50359
50360         int
50361         getNumOperands() override
50362         {
50363             return numDstRegOperands() + numSrcRegOperands();
50364         } // getNumOperands
50365
50366         int numDstRegOperands() override { return 1; }
50367         int numSrcRegOperands() override { return 1; }
50368
50369         int
50370         getOperandSize(int opIdx) override
50371         {
50372             switch (opIdx) {
50373               case 0: //src
50374                 return 4;
50375               case 1: //vdst
50376                 return 4;
50377               default:
50378                 fatal("op idx %i out of bounds\n", opIdx);
50379                 return -1;
50380             }
50381         } // getOperandSize
50382
50383         bool
50384         isSrcOperand(int opIdx) override
50385         {
50386             switch (opIdx) {
50387               case 0: //src
50388                 return true;
50389               case 1: //vdst
50390                 return false;
50391               default:
50392                 fatal("op idx %i out of bounds\n", opIdx);
50393                 return false;
50394             }
50395         } // isSrcOperand
50396
50397         bool
50398         isDstOperand(int opIdx) override
50399         {
50400             switch (opIdx) {
50401               case 0: //src
50402                 return false;
50403               case 1: //vdst
50404                 return true;
50405               default:
50406                 fatal("op idx %i out of bounds\n", opIdx);
50407                 return false;
50408             }
50409         } // isDstOperand
50410
50411         void execute(GPUDynInstPtr) override;
50412     }; // Inst_VOP3__V_FLOOR_F32
50413
50414     class Inst_VOP3__V_EXP_F32 : public Inst_VOP3
50415     {
50416       public:
50417         Inst_VOP3__V_EXP_F32(InFmt_VOP3*);
50418         ~Inst_VOP3__V_EXP_F32();
50419
50420         int
50421         getNumOperands() override
50422         {
50423             return numDstRegOperands() + numSrcRegOperands();
50424         } // getNumOperands
50425
50426         int numDstRegOperands() override { return 1; }
50427         int numSrcRegOperands() override { return 1; }
50428
50429         int
50430         getOperandSize(int opIdx) override
50431         {
50432             switch (opIdx) {
50433               case 0: //src
50434                 return 4;
50435               case 1: //vdst
50436                 return 4;
50437               default:
50438                 fatal("op idx %i out of bounds\n", opIdx);
50439                 return -1;
50440             }
50441         } // getOperandSize
50442
50443         bool
50444         isSrcOperand(int opIdx) override
50445         {
50446             switch (opIdx) {
50447               case 0: //src
50448                 return true;
50449               case 1: //vdst
50450                 return false;
50451               default:
50452                 fatal("op idx %i out of bounds\n", opIdx);
50453                 return false;
50454             }
50455         } // isSrcOperand
50456
50457         bool
50458         isDstOperand(int opIdx) override
50459         {
50460             switch (opIdx) {
50461               case 0: //src
50462                 return false;
50463               case 1: //vdst
50464                 return true;
50465               default:
50466                 fatal("op idx %i out of bounds\n", opIdx);
50467                 return false;
50468             }
50469         } // isDstOperand
50470
50471         void execute(GPUDynInstPtr) override;
50472     }; // Inst_VOP3__V_EXP_F32
50473
50474     class Inst_VOP3__V_LOG_F32 : public Inst_VOP3
50475     {
50476       public:
50477         Inst_VOP3__V_LOG_F32(InFmt_VOP3*);
50478         ~Inst_VOP3__V_LOG_F32();
50479
50480         int
50481         getNumOperands() override
50482         {
50483             return numDstRegOperands() + numSrcRegOperands();
50484         } // getNumOperands
50485
50486         int numDstRegOperands() override { return 1; }
50487         int numSrcRegOperands() override { return 1; }
50488
50489         int
50490         getOperandSize(int opIdx) override
50491         {
50492             switch (opIdx) {
50493               case 0: //src
50494                 return 4;
50495               case 1: //vdst
50496                 return 4;
50497               default:
50498                 fatal("op idx %i out of bounds\n", opIdx);
50499                 return -1;
50500             }
50501         } // getOperandSize
50502
50503         bool
50504         isSrcOperand(int opIdx) override
50505         {
50506             switch (opIdx) {
50507               case 0: //src
50508                 return true;
50509               case 1: //vdst
50510                 return false;
50511               default:
50512                 fatal("op idx %i out of bounds\n", opIdx);
50513                 return false;
50514             }
50515         } // isSrcOperand
50516
50517         bool
50518         isDstOperand(int opIdx) override
50519         {
50520             switch (opIdx) {
50521               case 0: //src
50522                 return false;
50523               case 1: //vdst
50524                 return true;
50525               default:
50526                 fatal("op idx %i out of bounds\n", opIdx);
50527                 return false;
50528             }
50529         } // isDstOperand
50530
50531         void execute(GPUDynInstPtr) override;
50532     }; // Inst_VOP3__V_LOG_F32
50533
50534     class Inst_VOP3__V_RCP_F32 : public Inst_VOP3
50535     {
50536       public:
50537         Inst_VOP3__V_RCP_F32(InFmt_VOP3*);
50538         ~Inst_VOP3__V_RCP_F32();
50539
50540         int
50541         getNumOperands() override
50542         {
50543             return numDstRegOperands() + numSrcRegOperands();
50544         } // getNumOperands
50545
50546         int numDstRegOperands() override { return 1; }
50547         int numSrcRegOperands() override { return 1; }
50548
50549         int
50550         getOperandSize(int opIdx) override
50551         {
50552             switch (opIdx) {
50553               case 0: //src
50554                 return 4;
50555               case 1: //vdst
50556                 return 4;
50557               default:
50558                 fatal("op idx %i out of bounds\n", opIdx);
50559                 return -1;
50560             }
50561         } // getOperandSize
50562
50563         bool
50564         isSrcOperand(int opIdx) override
50565         {
50566             switch (opIdx) {
50567               case 0: //src
50568                 return true;
50569               case 1: //vdst
50570                 return false;
50571               default:
50572                 fatal("op idx %i out of bounds\n", opIdx);
50573                 return false;
50574             }
50575         } // isSrcOperand
50576
50577         bool
50578         isDstOperand(int opIdx) override
50579         {
50580             switch (opIdx) {
50581               case 0: //src
50582                 return false;
50583               case 1: //vdst
50584                 return true;
50585               default:
50586                 fatal("op idx %i out of bounds\n", opIdx);
50587                 return false;
50588             }
50589         } // isDstOperand
50590
50591         void execute(GPUDynInstPtr) override;
50592     }; // Inst_VOP3__V_RCP_F32
50593
50594     class Inst_VOP3__V_RCP_IFLAG_F32 : public Inst_VOP3
50595     {
50596       public:
50597         Inst_VOP3__V_RCP_IFLAG_F32(InFmt_VOP3*);
50598         ~Inst_VOP3__V_RCP_IFLAG_F32();
50599
50600         int
50601         getNumOperands() override
50602         {
50603             return numDstRegOperands() + numSrcRegOperands();
50604         } // getNumOperands
50605
50606         int numDstRegOperands() override { return 1; }
50607         int numSrcRegOperands() override { return 1; }
50608
50609         int
50610         getOperandSize(int opIdx) override
50611         {
50612             switch (opIdx) {
50613               case 0: //src
50614                 return 4;
50615               case 1: //vdst
50616                 return 4;
50617               default:
50618                 fatal("op idx %i out of bounds\n", opIdx);
50619                 return -1;
50620             }
50621         } // getOperandSize
50622
50623         bool
50624         isSrcOperand(int opIdx) override
50625         {
50626             switch (opIdx) {
50627               case 0: //src
50628                 return true;
50629               case 1: //vdst
50630                 return false;
50631               default:
50632                 fatal("op idx %i out of bounds\n", opIdx);
50633                 return false;
50634             }
50635         } // isSrcOperand
50636
50637         bool
50638         isDstOperand(int opIdx) override
50639         {
50640             switch (opIdx) {
50641               case 0: //src
50642                 return false;
50643               case 1: //vdst
50644                 return true;
50645               default:
50646                 fatal("op idx %i out of bounds\n", opIdx);
50647                 return false;
50648             }
50649         } // isDstOperand
50650
50651         void execute(GPUDynInstPtr) override;
50652     }; // Inst_VOP3__V_RCP_IFLAG_F32
50653
50654     class Inst_VOP3__V_RSQ_F32 : public Inst_VOP3
50655     {
50656       public:
50657         Inst_VOP3__V_RSQ_F32(InFmt_VOP3*);
50658         ~Inst_VOP3__V_RSQ_F32();
50659
50660         int
50661         getNumOperands() override
50662         {
50663             return numDstRegOperands() + numSrcRegOperands();
50664         } // getNumOperands
50665
50666         int numDstRegOperands() override { return 1; }
50667         int numSrcRegOperands() override { return 1; }
50668
50669         int
50670         getOperandSize(int opIdx) override
50671         {
50672             switch (opIdx) {
50673               case 0: //src
50674                 return 4;
50675               case 1: //vdst
50676                 return 4;
50677               default:
50678                 fatal("op idx %i out of bounds\n", opIdx);
50679                 return -1;
50680             }
50681         } // getOperandSize
50682
50683         bool
50684         isSrcOperand(int opIdx) override
50685         {
50686             switch (opIdx) {
50687               case 0: //src
50688                 return true;
50689               case 1: //vdst
50690                 return false;
50691               default:
50692                 fatal("op idx %i out of bounds\n", opIdx);
50693                 return false;
50694             }
50695         } // isSrcOperand
50696
50697         bool
50698         isDstOperand(int opIdx) override
50699         {
50700             switch (opIdx) {
50701               case 0: //src
50702                 return false;
50703               case 1: //vdst
50704                 return true;
50705               default:
50706                 fatal("op idx %i out of bounds\n", opIdx);
50707                 return false;
50708             }
50709         } // isDstOperand
50710
50711         void execute(GPUDynInstPtr) override;
50712     }; // Inst_VOP3__V_RSQ_F32
50713
50714     class Inst_VOP3__V_RCP_F64 : public Inst_VOP3
50715     {
50716       public:
50717         Inst_VOP3__V_RCP_F64(InFmt_VOP3*);
50718         ~Inst_VOP3__V_RCP_F64();
50719
50720         int
50721         getNumOperands() override
50722         {
50723             return numDstRegOperands() + numSrcRegOperands();
50724         } // getNumOperands
50725
50726         int numDstRegOperands() override { return 1; }
50727         int numSrcRegOperands() override { return 1; }
50728
50729         int
50730         getOperandSize(int opIdx) override
50731         {
50732             switch (opIdx) {
50733               case 0: //src
50734                 return 8;
50735               case 1: //vdst
50736                 return 8;
50737               default:
50738                 fatal("op idx %i out of bounds\n", opIdx);
50739                 return -1;
50740             }
50741         } // getOperandSize
50742
50743         bool
50744         isSrcOperand(int opIdx) override
50745         {
50746             switch (opIdx) {
50747               case 0: //src
50748                 return true;
50749               case 1: //vdst
50750                 return false;
50751               default:
50752                 fatal("op idx %i out of bounds\n", opIdx);
50753                 return false;
50754             }
50755         } // isSrcOperand
50756
50757         bool
50758         isDstOperand(int opIdx) override
50759         {
50760             switch (opIdx) {
50761               case 0: //src
50762                 return false;
50763               case 1: //vdst
50764                 return true;
50765               default:
50766                 fatal("op idx %i out of bounds\n", opIdx);
50767                 return false;
50768             }
50769         } // isDstOperand
50770
50771         void execute(GPUDynInstPtr) override;
50772     }; // Inst_VOP3__V_RCP_F64
50773
50774     class Inst_VOP3__V_RSQ_F64 : public Inst_VOP3
50775     {
50776       public:
50777         Inst_VOP3__V_RSQ_F64(InFmt_VOP3*);
50778         ~Inst_VOP3__V_RSQ_F64();
50779
50780         int
50781         getNumOperands() override
50782         {
50783             return numDstRegOperands() + numSrcRegOperands();
50784         } // getNumOperands
50785
50786         int numDstRegOperands() override { return 1; }
50787         int numSrcRegOperands() override { return 1; }
50788
50789         int
50790         getOperandSize(int opIdx) override
50791         {
50792             switch (opIdx) {
50793               case 0: //src
50794                 return 8;
50795               case 1: //vdst
50796                 return 8;
50797               default:
50798                 fatal("op idx %i out of bounds\n", opIdx);
50799                 return -1;
50800             }
50801         } // getOperandSize
50802
50803         bool
50804         isSrcOperand(int opIdx) override
50805         {
50806             switch (opIdx) {
50807               case 0: //src
50808                 return true;
50809               case 1: //vdst
50810                 return false;
50811               default:
50812                 fatal("op idx %i out of bounds\n", opIdx);
50813                 return false;
50814             }
50815         } // isSrcOperand
50816
50817         bool
50818         isDstOperand(int opIdx) override
50819         {
50820             switch (opIdx) {
50821               case 0: //src
50822                 return false;
50823               case 1: //vdst
50824                 return true;
50825               default:
50826                 fatal("op idx %i out of bounds\n", opIdx);
50827                 return false;
50828             }
50829         } // isDstOperand
50830
50831         void execute(GPUDynInstPtr) override;
50832     }; // Inst_VOP3__V_RSQ_F64
50833
50834     class Inst_VOP3__V_SQRT_F32 : public Inst_VOP3
50835     {
50836       public:
50837         Inst_VOP3__V_SQRT_F32(InFmt_VOP3*);
50838         ~Inst_VOP3__V_SQRT_F32();
50839
50840         int
50841         getNumOperands() override
50842         {
50843             return numDstRegOperands() + numSrcRegOperands();
50844         } // getNumOperands
50845
50846         int numDstRegOperands() override { return 1; }
50847         int numSrcRegOperands() override { return 1; }
50848
50849         int
50850         getOperandSize(int opIdx) override
50851         {
50852             switch (opIdx) {
50853               case 0: //src
50854                 return 4;
50855               case 1: //vdst
50856                 return 4;
50857               default:
50858                 fatal("op idx %i out of bounds\n", opIdx);
50859                 return -1;
50860             }
50861         } // getOperandSize
50862
50863         bool
50864         isSrcOperand(int opIdx) override
50865         {
50866             switch (opIdx) {
50867               case 0: //src
50868                 return true;
50869               case 1: //vdst
50870                 return false;
50871               default:
50872                 fatal("op idx %i out of bounds\n", opIdx);
50873                 return false;
50874             }
50875         } // isSrcOperand
50876
50877         bool
50878         isDstOperand(int opIdx) override
50879         {
50880             switch (opIdx) {
50881               case 0: //src
50882                 return false;
50883               case 1: //vdst
50884                 return true;
50885               default:
50886                 fatal("op idx %i out of bounds\n", opIdx);
50887                 return false;
50888             }
50889         } // isDstOperand
50890
50891         void execute(GPUDynInstPtr) override;
50892     }; // Inst_VOP3__V_SQRT_F32
50893
50894     class Inst_VOP3__V_SQRT_F64 : public Inst_VOP3
50895     {
50896       public:
50897         Inst_VOP3__V_SQRT_F64(InFmt_VOP3*);
50898         ~Inst_VOP3__V_SQRT_F64();
50899
50900         int
50901         getNumOperands() override
50902         {
50903             return numDstRegOperands() + numSrcRegOperands();
50904         } // getNumOperands
50905
50906         int numDstRegOperands() override { return 1; }
50907         int numSrcRegOperands() override { return 1; }
50908
50909         int
50910         getOperandSize(int opIdx) override
50911         {
50912             switch (opIdx) {
50913               case 0: //src
50914                 return 8;
50915               case 1: //vdst
50916                 return 8;
50917               default:
50918                 fatal("op idx %i out of bounds\n", opIdx);
50919                 return -1;
50920             }
50921         } // getOperandSize
50922
50923         bool
50924         isSrcOperand(int opIdx) override
50925         {
50926             switch (opIdx) {
50927               case 0: //src
50928                 return true;
50929               case 1: //vdst
50930                 return false;
50931               default:
50932                 fatal("op idx %i out of bounds\n", opIdx);
50933                 return false;
50934             }
50935         } // isSrcOperand
50936
50937         bool
50938         isDstOperand(int opIdx) override
50939         {
50940             switch (opIdx) {
50941               case 0: //src
50942                 return false;
50943               case 1: //vdst
50944                 return true;
50945               default:
50946                 fatal("op idx %i out of bounds\n", opIdx);
50947                 return false;
50948             }
50949         } // isDstOperand
50950
50951         void execute(GPUDynInstPtr) override;
50952     }; // Inst_VOP3__V_SQRT_F64
50953
50954     class Inst_VOP3__V_SIN_F32 : public Inst_VOP3
50955     {
50956       public:
50957         Inst_VOP3__V_SIN_F32(InFmt_VOP3*);
50958         ~Inst_VOP3__V_SIN_F32();
50959
50960         int
50961         getNumOperands() override
50962         {
50963             return numDstRegOperands() + numSrcRegOperands();
50964         } // getNumOperands
50965
50966         int numDstRegOperands() override { return 1; }
50967         int numSrcRegOperands() override { return 1; }
50968
50969         int
50970         getOperandSize(int opIdx) override
50971         {
50972             switch (opIdx) {
50973               case 0: //src
50974                 return 4;
50975               case 1: //vdst
50976                 return 4;
50977               default:
50978                 fatal("op idx %i out of bounds\n", opIdx);
50979                 return -1;
50980             }
50981         } // getOperandSize
50982
50983         bool
50984         isSrcOperand(int opIdx) override
50985         {
50986             switch (opIdx) {
50987               case 0: //src
50988                 return true;
50989               case 1: //vdst
50990                 return false;
50991               default:
50992                 fatal("op idx %i out of bounds\n", opIdx);
50993                 return false;
50994             }
50995         } // isSrcOperand
50996
50997         bool
50998         isDstOperand(int opIdx) override
50999         {
51000             switch (opIdx) {
51001               case 0: //src
51002                 return false;
51003               case 1: //vdst
51004                 return true;
51005               default:
51006                 fatal("op idx %i out of bounds\n", opIdx);
51007                 return false;
51008             }
51009         } // isDstOperand
51010
51011         void execute(GPUDynInstPtr) override;
51012     }; // Inst_VOP3__V_SIN_F32
51013
51014     class Inst_VOP3__V_COS_F32 : public Inst_VOP3
51015     {
51016       public:
51017         Inst_VOP3__V_COS_F32(InFmt_VOP3*);
51018         ~Inst_VOP3__V_COS_F32();
51019
51020         int
51021         getNumOperands() override
51022         {
51023             return numDstRegOperands() + numSrcRegOperands();
51024         } // getNumOperands
51025
51026         int numDstRegOperands() override { return 1; }
51027         int numSrcRegOperands() override { return 1; }
51028
51029         int
51030         getOperandSize(int opIdx) override
51031         {
51032             switch (opIdx) {
51033               case 0: //src
51034                 return 4;
51035               case 1: //vdst
51036                 return 4;
51037               default:
51038                 fatal("op idx %i out of bounds\n", opIdx);
51039                 return -1;
51040             }
51041         } // getOperandSize
51042
51043         bool
51044         isSrcOperand(int opIdx) override
51045         {
51046             switch (opIdx) {
51047               case 0: //src
51048                 return true;
51049               case 1: //vdst
51050                 return false;
51051               default:
51052                 fatal("op idx %i out of bounds\n", opIdx);
51053                 return false;
51054             }
51055         } // isSrcOperand
51056
51057         bool
51058         isDstOperand(int opIdx) override
51059         {
51060             switch (opIdx) {
51061               case 0: //src
51062                 return false;
51063               case 1: //vdst
51064                 return true;
51065               default:
51066                 fatal("op idx %i out of bounds\n", opIdx);
51067                 return false;
51068             }
51069         } // isDstOperand
51070
51071         void execute(GPUDynInstPtr) override;
51072     }; // Inst_VOP3__V_COS_F32
51073
51074     class Inst_VOP3__V_NOT_B32 : public Inst_VOP3
51075     {
51076       public:
51077         Inst_VOP3__V_NOT_B32(InFmt_VOP3*);
51078         ~Inst_VOP3__V_NOT_B32();
51079
51080         int
51081         getNumOperands() override
51082         {
51083             return numDstRegOperands() + numSrcRegOperands();
51084         } // getNumOperands
51085
51086         int numDstRegOperands() override { return 1; }
51087         int numSrcRegOperands() override { return 1; }
51088
51089         int
51090         getOperandSize(int opIdx) override
51091         {
51092             switch (opIdx) {
51093               case 0: //src
51094                 return 4;
51095               case 1: //vdst
51096                 return 4;
51097               default:
51098                 fatal("op idx %i out of bounds\n", opIdx);
51099                 return -1;
51100             }
51101         } // getOperandSize
51102
51103         bool
51104         isSrcOperand(int opIdx) override
51105         {
51106             switch (opIdx) {
51107               case 0: //src
51108                 return true;
51109               case 1: //vdst
51110                 return false;
51111               default:
51112                 fatal("op idx %i out of bounds\n", opIdx);
51113                 return false;
51114             }
51115         } // isSrcOperand
51116
51117         bool
51118         isDstOperand(int opIdx) override
51119         {
51120             switch (opIdx) {
51121               case 0: //src
51122                 return false;
51123               case 1: //vdst
51124                 return true;
51125               default:
51126                 fatal("op idx %i out of bounds\n", opIdx);
51127                 return false;
51128             }
51129         } // isDstOperand
51130
51131         void execute(GPUDynInstPtr) override;
51132     }; // Inst_VOP3__V_NOT_B32
51133
51134     class Inst_VOP3__V_BFREV_B32 : public Inst_VOP3
51135     {
51136       public:
51137         Inst_VOP3__V_BFREV_B32(InFmt_VOP3*);
51138         ~Inst_VOP3__V_BFREV_B32();
51139
51140         int
51141         getNumOperands() override
51142         {
51143             return numDstRegOperands() + numSrcRegOperands();
51144         } // getNumOperands
51145
51146         int numDstRegOperands() override { return 1; }
51147         int numSrcRegOperands() override { return 1; }
51148
51149         int
51150         getOperandSize(int opIdx) override
51151         {
51152             switch (opIdx) {
51153               case 0: //src
51154                 return 4;
51155               case 1: //vdst
51156                 return 4;
51157               default:
51158                 fatal("op idx %i out of bounds\n", opIdx);
51159                 return -1;
51160             }
51161         } // getOperandSize
51162
51163         bool
51164         isSrcOperand(int opIdx) override
51165         {
51166             switch (opIdx) {
51167               case 0: //src
51168                 return true;
51169               case 1: //vdst
51170                 return false;
51171               default:
51172                 fatal("op idx %i out of bounds\n", opIdx);
51173                 return false;
51174             }
51175         } // isSrcOperand
51176
51177         bool
51178         isDstOperand(int opIdx) override
51179         {
51180             switch (opIdx) {
51181               case 0: //src
51182                 return false;
51183               case 1: //vdst
51184                 return true;
51185               default:
51186                 fatal("op idx %i out of bounds\n", opIdx);
51187                 return false;
51188             }
51189         } // isDstOperand
51190
51191         void execute(GPUDynInstPtr) override;
51192     }; // Inst_VOP3__V_BFREV_B32
51193
51194     class Inst_VOP3__V_FFBH_U32 : public Inst_VOP3
51195     {
51196       public:
51197         Inst_VOP3__V_FFBH_U32(InFmt_VOP3*);
51198         ~Inst_VOP3__V_FFBH_U32();
51199
51200         int
51201         getNumOperands() override
51202         {
51203             return numDstRegOperands() + numSrcRegOperands();
51204         } // getNumOperands
51205
51206         int numDstRegOperands() override { return 1; }
51207         int numSrcRegOperands() override { return 1; }
51208
51209         int
51210         getOperandSize(int opIdx) override
51211         {
51212             switch (opIdx) {
51213               case 0: //src
51214                 return 4;
51215               case 1: //vdst
51216                 return 4;
51217               default:
51218                 fatal("op idx %i out of bounds\n", opIdx);
51219                 return -1;
51220             }
51221         } // getOperandSize
51222
51223         bool
51224         isSrcOperand(int opIdx) override
51225         {
51226             switch (opIdx) {
51227               case 0: //src
51228                 return true;
51229               case 1: //vdst
51230                 return false;
51231               default:
51232                 fatal("op idx %i out of bounds\n", opIdx);
51233                 return false;
51234             }
51235         } // isSrcOperand
51236
51237         bool
51238         isDstOperand(int opIdx) override
51239         {
51240             switch (opIdx) {
51241               case 0: //src
51242                 return false;
51243               case 1: //vdst
51244                 return true;
51245               default:
51246                 fatal("op idx %i out of bounds\n", opIdx);
51247                 return false;
51248             }
51249         } // isDstOperand
51250
51251         void execute(GPUDynInstPtr) override;
51252     }; // Inst_VOP3__V_FFBH_U32
51253
51254     class Inst_VOP3__V_FFBL_B32 : public Inst_VOP3
51255     {
51256       public:
51257         Inst_VOP3__V_FFBL_B32(InFmt_VOP3*);
51258         ~Inst_VOP3__V_FFBL_B32();
51259
51260         int
51261         getNumOperands() override
51262         {
51263             return numDstRegOperands() + numSrcRegOperands();
51264         } // getNumOperands
51265
51266         int numDstRegOperands() override { return 1; }
51267         int numSrcRegOperands() override { return 1; }
51268
51269         int
51270         getOperandSize(int opIdx) override
51271         {
51272             switch (opIdx) {
51273               case 0: //src
51274                 return 4;
51275               case 1: //vdst
51276                 return 4;
51277               default:
51278                 fatal("op idx %i out of bounds\n", opIdx);
51279                 return -1;
51280             }
51281         } // getOperandSize
51282
51283         bool
51284         isSrcOperand(int opIdx) override
51285         {
51286             switch (opIdx) {
51287               case 0: //src
51288                 return true;
51289               case 1: //vdst
51290                 return false;
51291               default:
51292                 fatal("op idx %i out of bounds\n", opIdx);
51293                 return false;
51294             }
51295         } // isSrcOperand
51296
51297         bool
51298         isDstOperand(int opIdx) override
51299         {
51300             switch (opIdx) {
51301               case 0: //src
51302                 return false;
51303               case 1: //vdst
51304                 return true;
51305               default:
51306                 fatal("op idx %i out of bounds\n", opIdx);
51307                 return false;
51308             }
51309         } // isDstOperand
51310
51311         void execute(GPUDynInstPtr) override;
51312     }; // Inst_VOP3__V_FFBL_B32
51313
51314     class Inst_VOP3__V_FFBH_I32 : public Inst_VOP3
51315     {
51316       public:
51317         Inst_VOP3__V_FFBH_I32(InFmt_VOP3*);
51318         ~Inst_VOP3__V_FFBH_I32();
51319
51320         int
51321         getNumOperands() override
51322         {
51323             return numDstRegOperands() + numSrcRegOperands();
51324         } // getNumOperands
51325
51326         int numDstRegOperands() override { return 1; }
51327         int numSrcRegOperands() override { return 1; }
51328
51329         int
51330         getOperandSize(int opIdx) override
51331         {
51332             switch (opIdx) {
51333               case 0: //src
51334                 return 4;
51335               case 1: //vdst
51336                 return 4;
51337               default:
51338                 fatal("op idx %i out of bounds\n", opIdx);
51339                 return -1;
51340             }
51341         } // getOperandSize
51342
51343         bool
51344         isSrcOperand(int opIdx) override
51345         {
51346             switch (opIdx) {
51347               case 0: //src
51348                 return true;
51349               case 1: //vdst
51350                 return false;
51351               default:
51352                 fatal("op idx %i out of bounds\n", opIdx);
51353                 return false;
51354             }
51355         } // isSrcOperand
51356
51357         bool
51358         isDstOperand(int opIdx) override
51359         {
51360             switch (opIdx) {
51361               case 0: //src
51362                 return false;
51363               case 1: //vdst
51364                 return true;
51365               default:
51366                 fatal("op idx %i out of bounds\n", opIdx);
51367                 return false;
51368             }
51369         } // isDstOperand
51370
51371         void execute(GPUDynInstPtr) override;
51372     }; // Inst_VOP3__V_FFBH_I32
51373
51374     class Inst_VOP3__V_FREXP_EXP_I32_F64 : public Inst_VOP3
51375     {
51376       public:
51377         Inst_VOP3__V_FREXP_EXP_I32_F64(InFmt_VOP3*);
51378         ~Inst_VOP3__V_FREXP_EXP_I32_F64();
51379
51380         int
51381         getNumOperands() override
51382         {
51383             return numDstRegOperands() + numSrcRegOperands();
51384         } // getNumOperands
51385
51386         int numDstRegOperands() override { return 1; }
51387         int numSrcRegOperands() override { return 1; }
51388
51389         int
51390         getOperandSize(int opIdx) override
51391         {
51392             switch (opIdx) {
51393               case 0: //src
51394                 return 8;
51395               case 1: //vdst
51396                 return 4;
51397               default:
51398                 fatal("op idx %i out of bounds\n", opIdx);
51399                 return -1;
51400             }
51401         } // getOperandSize
51402
51403         bool
51404         isSrcOperand(int opIdx) override
51405         {
51406             switch (opIdx) {
51407               case 0: //src
51408                 return true;
51409               case 1: //vdst
51410                 return false;
51411               default:
51412                 fatal("op idx %i out of bounds\n", opIdx);
51413                 return false;
51414             }
51415         } // isSrcOperand
51416
51417         bool
51418         isDstOperand(int opIdx) override
51419         {
51420             switch (opIdx) {
51421               case 0: //src
51422                 return false;
51423               case 1: //vdst
51424                 return true;
51425               default:
51426                 fatal("op idx %i out of bounds\n", opIdx);
51427                 return false;
51428             }
51429         } // isDstOperand
51430
51431         void execute(GPUDynInstPtr) override;
51432     }; // Inst_VOP3__V_FREXP_EXP_I32_F64
51433
51434     class Inst_VOP3__V_FREXP_MANT_F64 : public Inst_VOP3
51435     {
51436       public:
51437         Inst_VOP3__V_FREXP_MANT_F64(InFmt_VOP3*);
51438         ~Inst_VOP3__V_FREXP_MANT_F64();
51439
51440         int
51441         getNumOperands() override
51442         {
51443             return numDstRegOperands() + numSrcRegOperands();
51444         } // getNumOperands
51445
51446         int numDstRegOperands() override { return 1; }
51447         int numSrcRegOperands() override { return 1; }
51448
51449         int
51450         getOperandSize(int opIdx) override
51451         {
51452             switch (opIdx) {
51453               case 0: //src
51454                 return 8;
51455               case 1: //vdst
51456                 return 8;
51457               default:
51458                 fatal("op idx %i out of bounds\n", opIdx);
51459                 return -1;
51460             }
51461         } // getOperandSize
51462
51463         bool
51464         isSrcOperand(int opIdx) override
51465         {
51466             switch (opIdx) {
51467               case 0: //src
51468                 return true;
51469               case 1: //vdst
51470                 return false;
51471               default:
51472                 fatal("op idx %i out of bounds\n", opIdx);
51473                 return false;
51474             }
51475         } // isSrcOperand
51476
51477         bool
51478         isDstOperand(int opIdx) override
51479         {
51480             switch (opIdx) {
51481               case 0: //src
51482                 return false;
51483               case 1: //vdst
51484                 return true;
51485               default:
51486                 fatal("op idx %i out of bounds\n", opIdx);
51487                 return false;
51488             }
51489         } // isDstOperand
51490
51491         void execute(GPUDynInstPtr) override;
51492     }; // Inst_VOP3__V_FREXP_MANT_F64
51493
51494     class Inst_VOP3__V_FRACT_F64 : public Inst_VOP3
51495     {
51496       public:
51497         Inst_VOP3__V_FRACT_F64(InFmt_VOP3*);
51498         ~Inst_VOP3__V_FRACT_F64();
51499
51500         int
51501         getNumOperands() override
51502         {
51503             return numDstRegOperands() + numSrcRegOperands();
51504         } // getNumOperands
51505
51506         int numDstRegOperands() override { return 1; }
51507         int numSrcRegOperands() override { return 1; }
51508
51509         int
51510         getOperandSize(int opIdx) override
51511         {
51512             switch (opIdx) {
51513               case 0: //src
51514                 return 8;
51515               case 1: //vdst
51516                 return 8;
51517               default:
51518                 fatal("op idx %i out of bounds\n", opIdx);
51519                 return -1;
51520             }
51521         } // getOperandSize
51522
51523         bool
51524         isSrcOperand(int opIdx) override
51525         {
51526             switch (opIdx) {
51527               case 0: //src
51528                 return true;
51529               case 1: //vdst
51530                 return false;
51531               default:
51532                 fatal("op idx %i out of bounds\n", opIdx);
51533                 return false;
51534             }
51535         } // isSrcOperand
51536
51537         bool
51538         isDstOperand(int opIdx) override
51539         {
51540             switch (opIdx) {
51541               case 0: //src
51542                 return false;
51543               case 1: //vdst
51544                 return true;
51545               default:
51546                 fatal("op idx %i out of bounds\n", opIdx);
51547                 return false;
51548             }
51549         } // isDstOperand
51550
51551         void execute(GPUDynInstPtr) override;
51552     }; // Inst_VOP3__V_FRACT_F64
51553
51554     class Inst_VOP3__V_FREXP_EXP_I32_F32 : public Inst_VOP3
51555     {
51556       public:
51557         Inst_VOP3__V_FREXP_EXP_I32_F32(InFmt_VOP3*);
51558         ~Inst_VOP3__V_FREXP_EXP_I32_F32();
51559
51560         int
51561         getNumOperands() override
51562         {
51563             return numDstRegOperands() + numSrcRegOperands();
51564         } // getNumOperands
51565
51566         int numDstRegOperands() override { return 1; }
51567         int numSrcRegOperands() override { return 1; }
51568
51569         int
51570         getOperandSize(int opIdx) override
51571         {
51572             switch (opIdx) {
51573               case 0: //src
51574                 return 4;
51575               case 1: //vdst
51576                 return 4;
51577               default:
51578                 fatal("op idx %i out of bounds\n", opIdx);
51579                 return -1;
51580             }
51581         } // getOperandSize
51582
51583         bool
51584         isSrcOperand(int opIdx) override
51585         {
51586             switch (opIdx) {
51587               case 0: //src
51588                 return true;
51589               case 1: //vdst
51590                 return false;
51591               default:
51592                 fatal("op idx %i out of bounds\n", opIdx);
51593                 return false;
51594             }
51595         } // isSrcOperand
51596
51597         bool
51598         isDstOperand(int opIdx) override
51599         {
51600             switch (opIdx) {
51601               case 0: //src
51602                 return false;
51603               case 1: //vdst
51604                 return true;
51605               default:
51606                 fatal("op idx %i out of bounds\n", opIdx);
51607                 return false;
51608             }
51609         } // isDstOperand
51610
51611         void execute(GPUDynInstPtr) override;
51612     }; // Inst_VOP3__V_FREXP_EXP_I32_F32
51613
51614     class Inst_VOP3__V_FREXP_MANT_F32 : public Inst_VOP3
51615     {
51616       public:
51617         Inst_VOP3__V_FREXP_MANT_F32(InFmt_VOP3*);
51618         ~Inst_VOP3__V_FREXP_MANT_F32();
51619
51620         int
51621         getNumOperands() override
51622         {
51623             return numDstRegOperands() + numSrcRegOperands();
51624         } // getNumOperands
51625
51626         int numDstRegOperands() override { return 1; }
51627         int numSrcRegOperands() override { return 1; }
51628
51629         int
51630         getOperandSize(int opIdx) override
51631         {
51632             switch (opIdx) {
51633               case 0: //src
51634                 return 4;
51635               case 1: //vdst
51636                 return 4;
51637               default:
51638                 fatal("op idx %i out of bounds\n", opIdx);
51639                 return -1;
51640             }
51641         } // getOperandSize
51642
51643         bool
51644         isSrcOperand(int opIdx) override
51645         {
51646             switch (opIdx) {
51647               case 0: //src
51648                 return true;
51649               case 1: //vdst
51650                 return false;
51651               default:
51652                 fatal("op idx %i out of bounds\n", opIdx);
51653                 return false;
51654             }
51655         } // isSrcOperand
51656
51657         bool
51658         isDstOperand(int opIdx) override
51659         {
51660             switch (opIdx) {
51661               case 0: //src
51662                 return false;
51663               case 1: //vdst
51664                 return true;
51665               default:
51666                 fatal("op idx %i out of bounds\n", opIdx);
51667                 return false;
51668             }
51669         } // isDstOperand
51670
51671         void execute(GPUDynInstPtr) override;
51672     }; // Inst_VOP3__V_FREXP_MANT_F32
51673
51674     class Inst_VOP3__V_CLREXCP : public Inst_VOP3
51675     {
51676       public:
51677         Inst_VOP3__V_CLREXCP(InFmt_VOP3*);
51678         ~Inst_VOP3__V_CLREXCP();
51679
51680         int
51681         getNumOperands() override
51682         {
51683             return numDstRegOperands() + numSrcRegOperands();
51684         } // getNumOperands
51685
51686         int numDstRegOperands() override { return 0; }
51687         int numSrcRegOperands() override { return 0; }
51688
51689         int
51690         getOperandSize(int opIdx) override
51691         {
51692             switch (opIdx) {
51693               default:
51694                 fatal("op idx %i out of bounds\n", opIdx);
51695                 return -1;
51696             }
51697         } // getOperandSize
51698
51699         bool
51700         isSrcOperand(int opIdx) override
51701         {
51702             switch (opIdx) {
51703               default:
51704                 fatal("op idx %i out of bounds\n", opIdx);
51705                 return false;
51706             }
51707         } // isSrcOperand
51708
51709         bool
51710         isDstOperand(int opIdx) override
51711         {
51712             switch (opIdx) {
51713               default:
51714                 fatal("op idx %i out of bounds\n", opIdx);
51715                 return false;
51716             }
51717         } // isDstOperand
51718
51719         void execute(GPUDynInstPtr) override;
51720     }; // Inst_VOP3__V_CLREXCP
51721
51722     class Inst_VOP3__V_CVT_F16_U16 : public Inst_VOP3
51723     {
51724       public:
51725         Inst_VOP3__V_CVT_F16_U16(InFmt_VOP3*);
51726         ~Inst_VOP3__V_CVT_F16_U16();
51727
51728         int
51729         getNumOperands() override
51730         {
51731             return numDstRegOperands() + numSrcRegOperands();
51732         } // getNumOperands
51733
51734         int numDstRegOperands() override { return 1; }
51735         int numSrcRegOperands() override { return 1; }
51736
51737         int
51738         getOperandSize(int opIdx) override
51739         {
51740             switch (opIdx) {
51741               case 0: //src
51742                 return 2;
51743               case 1: //vdst
51744                 return 2;
51745               default:
51746                 fatal("op idx %i out of bounds\n", opIdx);
51747                 return -1;
51748             }
51749         } // getOperandSize
51750
51751         bool
51752         isSrcOperand(int opIdx) override
51753         {
51754             switch (opIdx) {
51755               case 0: //src
51756                 return true;
51757               case 1: //vdst
51758                 return false;
51759               default:
51760                 fatal("op idx %i out of bounds\n", opIdx);
51761                 return false;
51762             }
51763         } // isSrcOperand
51764
51765         bool
51766         isDstOperand(int opIdx) override
51767         {
51768             switch (opIdx) {
51769               case 0: //src
51770                 return false;
51771               case 1: //vdst
51772                 return true;
51773               default:
51774                 fatal("op idx %i out of bounds\n", opIdx);
51775                 return false;
51776             }
51777         } // isDstOperand
51778
51779         void execute(GPUDynInstPtr) override;
51780     }; // Inst_VOP3__V_CVT_F16_U16
51781
51782     class Inst_VOP3__V_CVT_F16_I16 : public Inst_VOP3
51783     {
51784       public:
51785         Inst_VOP3__V_CVT_F16_I16(InFmt_VOP3*);
51786         ~Inst_VOP3__V_CVT_F16_I16();
51787
51788         int
51789         getNumOperands() override
51790         {
51791             return numDstRegOperands() + numSrcRegOperands();
51792         } // getNumOperands
51793
51794         int numDstRegOperands() override { return 1; }
51795         int numSrcRegOperands() override { return 1; }
51796
51797         int
51798         getOperandSize(int opIdx) override
51799         {
51800             switch (opIdx) {
51801               case 0: //src
51802                 return 2;
51803               case 1: //vdst
51804                 return 2;
51805               default:
51806                 fatal("op idx %i out of bounds\n", opIdx);
51807                 return -1;
51808             }
51809         } // getOperandSize
51810
51811         bool
51812         isSrcOperand(int opIdx) override
51813         {
51814             switch (opIdx) {
51815               case 0: //src
51816                 return true;
51817               case 1: //vdst
51818                 return false;
51819               default:
51820                 fatal("op idx %i out of bounds\n", opIdx);
51821                 return false;
51822             }
51823         } // isSrcOperand
51824
51825         bool
51826         isDstOperand(int opIdx) override
51827         {
51828             switch (opIdx) {
51829               case 0: //src
51830                 return false;
51831               case 1: //vdst
51832                 return true;
51833               default:
51834                 fatal("op idx %i out of bounds\n", opIdx);
51835                 return false;
51836             }
51837         } // isDstOperand
51838
51839         void execute(GPUDynInstPtr) override;
51840     }; // Inst_VOP3__V_CVT_F16_I16
51841
51842     class Inst_VOP3__V_CVT_U16_F16 : public Inst_VOP3
51843     {
51844       public:
51845         Inst_VOP3__V_CVT_U16_F16(InFmt_VOP3*);
51846         ~Inst_VOP3__V_CVT_U16_F16();
51847
51848         int
51849         getNumOperands() override
51850         {
51851             return numDstRegOperands() + numSrcRegOperands();
51852         } // getNumOperands
51853
51854         int numDstRegOperands() override { return 1; }
51855         int numSrcRegOperands() override { return 1; }
51856
51857         int
51858         getOperandSize(int opIdx) override
51859         {
51860             switch (opIdx) {
51861               case 0: //src
51862                 return 2;
51863               case 1: //vdst
51864                 return 2;
51865               default:
51866                 fatal("op idx %i out of bounds\n", opIdx);
51867                 return -1;
51868             }
51869         } // getOperandSize
51870
51871         bool
51872         isSrcOperand(int opIdx) override
51873         {
51874             switch (opIdx) {
51875               case 0: //src
51876                 return true;
51877               case 1: //vdst
51878                 return false;
51879               default:
51880                 fatal("op idx %i out of bounds\n", opIdx);
51881                 return false;
51882             }
51883         } // isSrcOperand
51884
51885         bool
51886         isDstOperand(int opIdx) override
51887         {
51888             switch (opIdx) {
51889               case 0: //src
51890                 return false;
51891               case 1: //vdst
51892                 return true;
51893               default:
51894                 fatal("op idx %i out of bounds\n", opIdx);
51895                 return false;
51896             }
51897         } // isDstOperand
51898
51899         void execute(GPUDynInstPtr) override;
51900     }; // Inst_VOP3__V_CVT_U16_F16
51901
51902     class Inst_VOP3__V_CVT_I16_F16 : public Inst_VOP3
51903     {
51904       public:
51905         Inst_VOP3__V_CVT_I16_F16(InFmt_VOP3*);
51906         ~Inst_VOP3__V_CVT_I16_F16();
51907
51908         int
51909         getNumOperands() override
51910         {
51911             return numDstRegOperands() + numSrcRegOperands();
51912         } // getNumOperands
51913
51914         int numDstRegOperands() override { return 1; }
51915         int numSrcRegOperands() override { return 1; }
51916
51917         int
51918         getOperandSize(int opIdx) override
51919         {
51920             switch (opIdx) {
51921               case 0: //src
51922                 return 2;
51923               case 1: //vdst
51924                 return 2;
51925               default:
51926                 fatal("op idx %i out of bounds\n", opIdx);
51927                 return -1;
51928             }
51929         } // getOperandSize
51930
51931         bool
51932         isSrcOperand(int opIdx) override
51933         {
51934             switch (opIdx) {
51935               case 0: //src
51936                 return true;
51937               case 1: //vdst
51938                 return false;
51939               default:
51940                 fatal("op idx %i out of bounds\n", opIdx);
51941                 return false;
51942             }
51943         } // isSrcOperand
51944
51945         bool
51946         isDstOperand(int opIdx) override
51947         {
51948             switch (opIdx) {
51949               case 0: //src
51950                 return false;
51951               case 1: //vdst
51952                 return true;
51953               default:
51954                 fatal("op idx %i out of bounds\n", opIdx);
51955                 return false;
51956             }
51957         } // isDstOperand
51958
51959         void execute(GPUDynInstPtr) override;
51960     }; // Inst_VOP3__V_CVT_I16_F16
51961
51962     class Inst_VOP3__V_RCP_F16 : public Inst_VOP3
51963     {
51964       public:
51965         Inst_VOP3__V_RCP_F16(InFmt_VOP3*);
51966         ~Inst_VOP3__V_RCP_F16();
51967
51968         int
51969         getNumOperands() override
51970         {
51971             return numDstRegOperands() + numSrcRegOperands();
51972         } // getNumOperands
51973
51974         int numDstRegOperands() override { return 1; }
51975         int numSrcRegOperands() override { return 1; }
51976
51977         int
51978         getOperandSize(int opIdx) override
51979         {
51980             switch (opIdx) {
51981               case 0: //src
51982                 return 2;
51983               case 1: //vdst
51984                 return 2;
51985               default:
51986                 fatal("op idx %i out of bounds\n", opIdx);
51987                 return -1;
51988             }
51989         } // getOperandSize
51990
51991         bool
51992         isSrcOperand(int opIdx) override
51993         {
51994             switch (opIdx) {
51995               case 0: //src
51996                 return true;
51997               case 1: //vdst
51998                 return false;
51999               default:
52000                 fatal("op idx %i out of bounds\n", opIdx);
52001                 return false;
52002             }
52003         } // isSrcOperand
52004
52005         bool
52006         isDstOperand(int opIdx) override
52007         {
52008             switch (opIdx) {
52009               case 0: //src
52010                 return false;
52011               case 1: //vdst
52012                 return true;
52013               default:
52014                 fatal("op idx %i out of bounds\n", opIdx);
52015                 return false;
52016             }
52017         } // isDstOperand
52018
52019         void execute(GPUDynInstPtr) override;
52020     }; // Inst_VOP3__V_RCP_F16
52021
52022     class Inst_VOP3__V_SQRT_F16 : public Inst_VOP3
52023     {
52024       public:
52025         Inst_VOP3__V_SQRT_F16(InFmt_VOP3*);
52026         ~Inst_VOP3__V_SQRT_F16();
52027
52028         int
52029         getNumOperands() override
52030         {
52031             return numDstRegOperands() + numSrcRegOperands();
52032         } // getNumOperands
52033
52034         int numDstRegOperands() override { return 1; }
52035         int numSrcRegOperands() override { return 1; }
52036
52037         int
52038         getOperandSize(int opIdx) override
52039         {
52040             switch (opIdx) {
52041               case 0: //src
52042                 return 2;
52043               case 1: //vdst
52044                 return 2;
52045               default:
52046                 fatal("op idx %i out of bounds\n", opIdx);
52047                 return -1;
52048             }
52049         } // getOperandSize
52050
52051         bool
52052         isSrcOperand(int opIdx) override
52053         {
52054             switch (opIdx) {
52055               case 0: //src
52056                 return true;
52057               case 1: //vdst
52058                 return false;
52059               default:
52060                 fatal("op idx %i out of bounds\n", opIdx);
52061                 return false;
52062             }
52063         } // isSrcOperand
52064
52065         bool
52066         isDstOperand(int opIdx) override
52067         {
52068             switch (opIdx) {
52069               case 0: //src
52070                 return false;
52071               case 1: //vdst
52072                 return true;
52073               default:
52074                 fatal("op idx %i out of bounds\n", opIdx);
52075                 return false;
52076             }
52077         } // isDstOperand
52078
52079         void execute(GPUDynInstPtr) override;
52080     }; // Inst_VOP3__V_SQRT_F16
52081
52082     class Inst_VOP3__V_RSQ_F16 : public Inst_VOP3
52083     {
52084       public:
52085         Inst_VOP3__V_RSQ_F16(InFmt_VOP3*);
52086         ~Inst_VOP3__V_RSQ_F16();
52087
52088         int
52089         getNumOperands() override
52090         {
52091             return numDstRegOperands() + numSrcRegOperands();
52092         } // getNumOperands
52093
52094         int numDstRegOperands() override { return 1; }
52095         int numSrcRegOperands() override { return 1; }
52096
52097         int
52098         getOperandSize(int opIdx) override
52099         {
52100             switch (opIdx) {
52101               case 0: //src
52102                 return 2;
52103               case 1: //vdst
52104                 return 2;
52105               default:
52106                 fatal("op idx %i out of bounds\n", opIdx);
52107                 return -1;
52108             }
52109         } // getOperandSize
52110
52111         bool
52112         isSrcOperand(int opIdx) override
52113         {
52114             switch (opIdx) {
52115               case 0: //src
52116                 return true;
52117               case 1: //vdst
52118                 return false;
52119               default:
52120                 fatal("op idx %i out of bounds\n", opIdx);
52121                 return false;
52122             }
52123         } // isSrcOperand
52124
52125         bool
52126         isDstOperand(int opIdx) override
52127         {
52128             switch (opIdx) {
52129               case 0: //src
52130                 return false;
52131               case 1: //vdst
52132                 return true;
52133               default:
52134                 fatal("op idx %i out of bounds\n", opIdx);
52135                 return false;
52136             }
52137         } // isDstOperand
52138
52139         void execute(GPUDynInstPtr) override;
52140     }; // Inst_VOP3__V_RSQ_F16
52141
52142     class Inst_VOP3__V_LOG_F16 : public Inst_VOP3
52143     {
52144       public:
52145         Inst_VOP3__V_LOG_F16(InFmt_VOP3*);
52146         ~Inst_VOP3__V_LOG_F16();
52147
52148         int
52149         getNumOperands() override
52150         {
52151             return numDstRegOperands() + numSrcRegOperands();
52152         } // getNumOperands
52153
52154         int numDstRegOperands() override { return 1; }
52155         int numSrcRegOperands() override { return 1; }
52156
52157         int
52158         getOperandSize(int opIdx) override
52159         {
52160             switch (opIdx) {
52161               case 0: //src
52162                 return 2;
52163               case 1: //vdst
52164                 return 2;
52165               default:
52166                 fatal("op idx %i out of bounds\n", opIdx);
52167                 return -1;
52168             }
52169         } // getOperandSize
52170
52171         bool
52172         isSrcOperand(int opIdx) override
52173         {
52174             switch (opIdx) {
52175               case 0: //src
52176                 return true;
52177               case 1: //vdst
52178                 return false;
52179               default:
52180                 fatal("op idx %i out of bounds\n", opIdx);
52181                 return false;
52182             }
52183         } // isSrcOperand
52184
52185         bool
52186         isDstOperand(int opIdx) override
52187         {
52188             switch (opIdx) {
52189               case 0: //src
52190                 return false;
52191               case 1: //vdst
52192                 return true;
52193               default:
52194                 fatal("op idx %i out of bounds\n", opIdx);
52195                 return false;
52196             }
52197         } // isDstOperand
52198
52199         void execute(GPUDynInstPtr) override;
52200     }; // Inst_VOP3__V_LOG_F16
52201
52202     class Inst_VOP3__V_EXP_F16 : public Inst_VOP3
52203     {
52204       public:
52205         Inst_VOP3__V_EXP_F16(InFmt_VOP3*);
52206         ~Inst_VOP3__V_EXP_F16();
52207
52208         int
52209         getNumOperands() override
52210         {
52211             return numDstRegOperands() + numSrcRegOperands();
52212         } // getNumOperands
52213
52214         int numDstRegOperands() override { return 1; }
52215         int numSrcRegOperands() override { return 1; }
52216
52217         int
52218         getOperandSize(int opIdx) override
52219         {
52220             switch (opIdx) {
52221               case 0: //src
52222                 return 2;
52223               case 1: //vdst
52224                 return 2;
52225               default:
52226                 fatal("op idx %i out of bounds\n", opIdx);
52227                 return -1;
52228             }
52229         } // getOperandSize
52230
52231         bool
52232         isSrcOperand(int opIdx) override
52233         {
52234             switch (opIdx) {
52235               case 0: //src
52236                 return true;
52237               case 1: //vdst
52238                 return false;
52239               default:
52240                 fatal("op idx %i out of bounds\n", opIdx);
52241                 return false;
52242             }
52243         } // isSrcOperand
52244
52245         bool
52246         isDstOperand(int opIdx) override
52247         {
52248             switch (opIdx) {
52249               case 0: //src
52250                 return false;
52251               case 1: //vdst
52252                 return true;
52253               default:
52254                 fatal("op idx %i out of bounds\n", opIdx);
52255                 return false;
52256             }
52257         } // isDstOperand
52258
52259         void execute(GPUDynInstPtr) override;
52260     }; // Inst_VOP3__V_EXP_F16
52261
52262     class Inst_VOP3__V_FREXP_MANT_F16 : public Inst_VOP3
52263     {
52264       public:
52265         Inst_VOP3__V_FREXP_MANT_F16(InFmt_VOP3*);
52266         ~Inst_VOP3__V_FREXP_MANT_F16();
52267
52268         int
52269         getNumOperands() override
52270         {
52271             return numDstRegOperands() + numSrcRegOperands();
52272         } // getNumOperands
52273
52274         int numDstRegOperands() override { return 1; }
52275         int numSrcRegOperands() override { return 1; }
52276
52277         int
52278         getOperandSize(int opIdx) override
52279         {
52280             switch (opIdx) {
52281               case 0: //src
52282                 return 2;
52283               case 1: //vdst
52284                 return 2;
52285               default:
52286                 fatal("op idx %i out of bounds\n", opIdx);
52287                 return -1;
52288             }
52289         } // getOperandSize
52290
52291         bool
52292         isSrcOperand(int opIdx) override
52293         {
52294             switch (opIdx) {
52295               case 0: //src
52296                 return true;
52297               case 1: //vdst
52298                 return false;
52299               default:
52300                 fatal("op idx %i out of bounds\n", opIdx);
52301                 return false;
52302             }
52303         } // isSrcOperand
52304
52305         bool
52306         isDstOperand(int opIdx) override
52307         {
52308             switch (opIdx) {
52309               case 0: //src
52310                 return false;
52311               case 1: //vdst
52312                 return true;
52313               default:
52314                 fatal("op idx %i out of bounds\n", opIdx);
52315                 return false;
52316             }
52317         } // isDstOperand
52318
52319         void execute(GPUDynInstPtr) override;
52320     }; // Inst_VOP3__V_FREXP_MANT_F16
52321
52322     class Inst_VOP3__V_FREXP_EXP_I16_F16 : public Inst_VOP3
52323     {
52324       public:
52325         Inst_VOP3__V_FREXP_EXP_I16_F16(InFmt_VOP3*);
52326         ~Inst_VOP3__V_FREXP_EXP_I16_F16();
52327
52328         int
52329         getNumOperands() override
52330         {
52331             return numDstRegOperands() + numSrcRegOperands();
52332         } // getNumOperands
52333
52334         int numDstRegOperands() override { return 1; }
52335         int numSrcRegOperands() override { return 1; }
52336
52337         int
52338         getOperandSize(int opIdx) override
52339         {
52340             switch (opIdx) {
52341               case 0: //src
52342                 return 2;
52343               case 1: //vdst
52344                 return 2;
52345               default:
52346                 fatal("op idx %i out of bounds\n", opIdx);
52347                 return -1;
52348             }
52349         } // getOperandSize
52350
52351         bool
52352         isSrcOperand(int opIdx) override
52353         {
52354             switch (opIdx) {
52355               case 0: //src
52356                 return true;
52357               case 1: //vdst
52358                 return false;
52359               default:
52360                 fatal("op idx %i out of bounds\n", opIdx);
52361                 return false;
52362             }
52363         } // isSrcOperand
52364
52365         bool
52366         isDstOperand(int opIdx) override
52367         {
52368             switch (opIdx) {
52369               case 0: //src
52370                 return false;
52371               case 1: //vdst
52372                 return true;
52373               default:
52374                 fatal("op idx %i out of bounds\n", opIdx);
52375                 return false;
52376             }
52377         } // isDstOperand
52378
52379         void execute(GPUDynInstPtr) override;
52380     }; // Inst_VOP3__V_FREXP_EXP_I16_F16
52381
52382     class Inst_VOP3__V_FLOOR_F16 : public Inst_VOP3
52383     {
52384       public:
52385         Inst_VOP3__V_FLOOR_F16(InFmt_VOP3*);
52386         ~Inst_VOP3__V_FLOOR_F16();
52387
52388         int
52389         getNumOperands() override
52390         {
52391             return numDstRegOperands() + numSrcRegOperands();
52392         } // getNumOperands
52393
52394         int numDstRegOperands() override { return 1; }
52395         int numSrcRegOperands() override { return 1; }
52396
52397         int
52398         getOperandSize(int opIdx) override
52399         {
52400             switch (opIdx) {
52401               case 0: //src
52402                 return 2;
52403               case 1: //vdst
52404                 return 2;
52405               default:
52406                 fatal("op idx %i out of bounds\n", opIdx);
52407                 return -1;
52408             }
52409         } // getOperandSize
52410
52411         bool
52412         isSrcOperand(int opIdx) override
52413         {
52414             switch (opIdx) {
52415               case 0: //src
52416                 return true;
52417               case 1: //vdst
52418                 return false;
52419               default:
52420                 fatal("op idx %i out of bounds\n", opIdx);
52421                 return false;
52422             }
52423         } // isSrcOperand
52424
52425         bool
52426         isDstOperand(int opIdx) override
52427         {
52428             switch (opIdx) {
52429               case 0: //src
52430                 return false;
52431               case 1: //vdst
52432                 return true;
52433               default:
52434                 fatal("op idx %i out of bounds\n", opIdx);
52435                 return false;
52436             }
52437         } // isDstOperand
52438
52439         void execute(GPUDynInstPtr) override;
52440     }; // Inst_VOP3__V_FLOOR_F16
52441
52442     class Inst_VOP3__V_CEIL_F16 : public Inst_VOP3
52443     {
52444       public:
52445         Inst_VOP3__V_CEIL_F16(InFmt_VOP3*);
52446         ~Inst_VOP3__V_CEIL_F16();
52447
52448         int
52449         getNumOperands() override
52450         {
52451             return numDstRegOperands() + numSrcRegOperands();
52452         } // getNumOperands
52453
52454         int numDstRegOperands() override { return 1; }
52455         int numSrcRegOperands() override { return 1; }
52456
52457         int
52458         getOperandSize(int opIdx) override
52459         {
52460             switch (opIdx) {
52461               case 0: //src
52462                 return 2;
52463               case 1: //vdst
52464                 return 2;
52465               default:
52466                 fatal("op idx %i out of bounds\n", opIdx);
52467                 return -1;
52468             }
52469         } // getOperandSize
52470
52471         bool
52472         isSrcOperand(int opIdx) override
52473         {
52474             switch (opIdx) {
52475               case 0: //src
52476                 return true;
52477               case 1: //vdst
52478                 return false;
52479               default:
52480                 fatal("op idx %i out of bounds\n", opIdx);
52481                 return false;
52482             }
52483         } // isSrcOperand
52484
52485         bool
52486         isDstOperand(int opIdx) override
52487         {
52488             switch (opIdx) {
52489               case 0: //src
52490                 return false;
52491               case 1: //vdst
52492                 return true;
52493               default:
52494                 fatal("op idx %i out of bounds\n", opIdx);
52495                 return false;
52496             }
52497         } // isDstOperand
52498
52499         void execute(GPUDynInstPtr) override;
52500     }; // Inst_VOP3__V_CEIL_F16
52501
52502     class Inst_VOP3__V_TRUNC_F16 : public Inst_VOP3
52503     {
52504       public:
52505         Inst_VOP3__V_TRUNC_F16(InFmt_VOP3*);
52506         ~Inst_VOP3__V_TRUNC_F16();
52507
52508         int
52509         getNumOperands() override
52510         {
52511             return numDstRegOperands() + numSrcRegOperands();
52512         } // getNumOperands
52513
52514         int numDstRegOperands() override { return 1; }
52515         int numSrcRegOperands() override { return 1; }
52516
52517         int
52518         getOperandSize(int opIdx) override
52519         {
52520             switch (opIdx) {
52521               case 0: //src
52522                 return 2;
52523               case 1: //vdst
52524                 return 2;
52525               default:
52526                 fatal("op idx %i out of bounds\n", opIdx);
52527                 return -1;
52528             }
52529         } // getOperandSize
52530
52531         bool
52532         isSrcOperand(int opIdx) override
52533         {
52534             switch (opIdx) {
52535               case 0: //src
52536                 return true;
52537               case 1: //vdst
52538                 return false;
52539               default:
52540                 fatal("op idx %i out of bounds\n", opIdx);
52541                 return false;
52542             }
52543         } // isSrcOperand
52544
52545         bool
52546         isDstOperand(int opIdx) override
52547         {
52548             switch (opIdx) {
52549               case 0: //src
52550                 return false;
52551               case 1: //vdst
52552                 return true;
52553               default:
52554                 fatal("op idx %i out of bounds\n", opIdx);
52555                 return false;
52556             }
52557         } // isDstOperand
52558
52559         void execute(GPUDynInstPtr) override;
52560     }; // Inst_VOP3__V_TRUNC_F16
52561
52562     class Inst_VOP3__V_RNDNE_F16 : public Inst_VOP3
52563     {
52564       public:
52565         Inst_VOP3__V_RNDNE_F16(InFmt_VOP3*);
52566         ~Inst_VOP3__V_RNDNE_F16();
52567
52568         int
52569         getNumOperands() override
52570         {
52571             return numDstRegOperands() + numSrcRegOperands();
52572         } // getNumOperands
52573
52574         int numDstRegOperands() override { return 1; }
52575         int numSrcRegOperands() override { return 1; }
52576
52577         int
52578         getOperandSize(int opIdx) override
52579         {
52580             switch (opIdx) {
52581               case 0: //src
52582                 return 2;
52583               case 1: //vdst
52584                 return 2;
52585               default:
52586                 fatal("op idx %i out of bounds\n", opIdx);
52587                 return -1;
52588             }
52589         } // getOperandSize
52590
52591         bool
52592         isSrcOperand(int opIdx) override
52593         {
52594             switch (opIdx) {
52595               case 0: //src
52596                 return true;
52597               case 1: //vdst
52598                 return false;
52599               default:
52600                 fatal("op idx %i out of bounds\n", opIdx);
52601                 return false;
52602             }
52603         } // isSrcOperand
52604
52605         bool
52606         isDstOperand(int opIdx) override
52607         {
52608             switch (opIdx) {
52609               case 0: //src
52610                 return false;
52611               case 1: //vdst
52612                 return true;
52613               default:
52614                 fatal("op idx %i out of bounds\n", opIdx);
52615                 return false;
52616             }
52617         } // isDstOperand
52618
52619         void execute(GPUDynInstPtr) override;
52620     }; // Inst_VOP3__V_RNDNE_F16
52621
52622     class Inst_VOP3__V_FRACT_F16 : public Inst_VOP3
52623     {
52624       public:
52625         Inst_VOP3__V_FRACT_F16(InFmt_VOP3*);
52626         ~Inst_VOP3__V_FRACT_F16();
52627
52628         int
52629         getNumOperands() override
52630         {
52631             return numDstRegOperands() + numSrcRegOperands();
52632         } // getNumOperands
52633
52634         int numDstRegOperands() override { return 1; }
52635         int numSrcRegOperands() override { return 1; }
52636
52637         int
52638         getOperandSize(int opIdx) override
52639         {
52640             switch (opIdx) {
52641               case 0: //src
52642                 return 2;
52643               case 1: //vdst
52644                 return 2;
52645               default:
52646                 fatal("op idx %i out of bounds\n", opIdx);
52647                 return -1;
52648             }
52649         } // getOperandSize
52650
52651         bool
52652         isSrcOperand(int opIdx) override
52653         {
52654             switch (opIdx) {
52655               case 0: //src
52656                 return true;
52657               case 1: //vdst
52658                 return false;
52659               default:
52660                 fatal("op idx %i out of bounds\n", opIdx);
52661                 return false;
52662             }
52663         } // isSrcOperand
52664
52665         bool
52666         isDstOperand(int opIdx) override
52667         {
52668             switch (opIdx) {
52669               case 0: //src
52670                 return false;
52671               case 1: //vdst
52672                 return true;
52673               default:
52674                 fatal("op idx %i out of bounds\n", opIdx);
52675                 return false;
52676             }
52677         } // isDstOperand
52678
52679         void execute(GPUDynInstPtr) override;
52680     }; // Inst_VOP3__V_FRACT_F16
52681
52682     class Inst_VOP3__V_SIN_F16 : public Inst_VOP3
52683     {
52684       public:
52685         Inst_VOP3__V_SIN_F16(InFmt_VOP3*);
52686         ~Inst_VOP3__V_SIN_F16();
52687
52688         int
52689         getNumOperands() override
52690         {
52691             return numDstRegOperands() + numSrcRegOperands();
52692         } // getNumOperands
52693
52694         int numDstRegOperands() override { return 1; }
52695         int numSrcRegOperands() override { return 1; }
52696
52697         int
52698         getOperandSize(int opIdx) override
52699         {
52700             switch (opIdx) {
52701               case 0: //src
52702                 return 2;
52703               case 1: //vdst
52704                 return 2;
52705               default:
52706                 fatal("op idx %i out of bounds\n", opIdx);
52707                 return -1;
52708             }
52709         } // getOperandSize
52710
52711         bool
52712         isSrcOperand(int opIdx) override
52713         {
52714             switch (opIdx) {
52715               case 0: //src
52716                 return true;
52717               case 1: //vdst
52718                 return false;
52719               default:
52720                 fatal("op idx %i out of bounds\n", opIdx);
52721                 return false;
52722             }
52723         } // isSrcOperand
52724
52725         bool
52726         isDstOperand(int opIdx) override
52727         {
52728             switch (opIdx) {
52729               case 0: //src
52730                 return false;
52731               case 1: //vdst
52732                 return true;
52733               default:
52734                 fatal("op idx %i out of bounds\n", opIdx);
52735                 return false;
52736             }
52737         } // isDstOperand
52738
52739         void execute(GPUDynInstPtr) override;
52740     }; // Inst_VOP3__V_SIN_F16
52741
52742     class Inst_VOP3__V_COS_F16 : public Inst_VOP3
52743     {
52744       public:
52745         Inst_VOP3__V_COS_F16(InFmt_VOP3*);
52746         ~Inst_VOP3__V_COS_F16();
52747
52748         int
52749         getNumOperands() override
52750         {
52751             return numDstRegOperands() + numSrcRegOperands();
52752         } // getNumOperands
52753
52754         int numDstRegOperands() override { return 1; }
52755         int numSrcRegOperands() override { return 1; }
52756
52757         int
52758         getOperandSize(int opIdx) override
52759         {
52760             switch (opIdx) {
52761               case 0: //src
52762                 return 2;
52763               case 1: //vdst
52764                 return 2;
52765               default:
52766                 fatal("op idx %i out of bounds\n", opIdx);
52767                 return -1;
52768             }
52769         } // getOperandSize
52770
52771         bool
52772         isSrcOperand(int opIdx) override
52773         {
52774             switch (opIdx) {
52775               case 0: //src
52776                 return true;
52777               case 1: //vdst
52778                 return false;
52779               default:
52780                 fatal("op idx %i out of bounds\n", opIdx);
52781                 return false;
52782             }
52783         } // isSrcOperand
52784
52785         bool
52786         isDstOperand(int opIdx) override
52787         {
52788             switch (opIdx) {
52789               case 0: //src
52790                 return false;
52791               case 1: //vdst
52792                 return true;
52793               default:
52794                 fatal("op idx %i out of bounds\n", opIdx);
52795                 return false;
52796             }
52797         } // isDstOperand
52798
52799         void execute(GPUDynInstPtr) override;
52800     }; // Inst_VOP3__V_COS_F16
52801
52802     class Inst_VOP3__V_EXP_LEGACY_F32 : public Inst_VOP3
52803     {
52804       public:
52805         Inst_VOP3__V_EXP_LEGACY_F32(InFmt_VOP3*);
52806         ~Inst_VOP3__V_EXP_LEGACY_F32();
52807
52808         int
52809         getNumOperands() override
52810         {
52811             return numDstRegOperands() + numSrcRegOperands();
52812         } // getNumOperands
52813
52814         int numDstRegOperands() override { return 1; }
52815         int numSrcRegOperands() override { return 1; }
52816
52817         int
52818         getOperandSize(int opIdx) override
52819         {
52820             switch (opIdx) {
52821               case 0: //src
52822                 return 4;
52823               case 1: //vdst
52824                 return 4;
52825               default:
52826                 fatal("op idx %i out of bounds\n", opIdx);
52827                 return -1;
52828             }
52829         } // getOperandSize
52830
52831         bool
52832         isSrcOperand(int opIdx) override
52833         {
52834             switch (opIdx) {
52835               case 0: //src
52836                 return true;
52837               case 1: //vdst
52838                 return false;
52839               default:
52840                 fatal("op idx %i out of bounds\n", opIdx);
52841                 return false;
52842             }
52843         } // isSrcOperand
52844
52845         bool
52846         isDstOperand(int opIdx) override
52847         {
52848             switch (opIdx) {
52849               case 0: //src
52850                 return false;
52851               case 1: //vdst
52852                 return true;
52853               default:
52854                 fatal("op idx %i out of bounds\n", opIdx);
52855                 return false;
52856             }
52857         } // isDstOperand
52858
52859         void execute(GPUDynInstPtr) override;
52860     }; // Inst_VOP3__V_EXP_LEGACY_F32
52861
52862     class Inst_VOP3__V_LOG_LEGACY_F32 : public Inst_VOP3
52863     {
52864       public:
52865         Inst_VOP3__V_LOG_LEGACY_F32(InFmt_VOP3*);
52866         ~Inst_VOP3__V_LOG_LEGACY_F32();
52867
52868         int
52869         getNumOperands() override
52870         {
52871             return numDstRegOperands() + numSrcRegOperands();
52872         } // getNumOperands
52873
52874         int numDstRegOperands() override { return 1; }
52875         int numSrcRegOperands() override { return 1; }
52876
52877         int
52878         getOperandSize(int opIdx) override
52879         {
52880             switch (opIdx) {
52881               case 0: //src
52882                 return 4;
52883               case 1: //vdst
52884                 return 4;
52885               default:
52886                 fatal("op idx %i out of bounds\n", opIdx);
52887                 return -1;
52888             }
52889         } // getOperandSize
52890
52891         bool
52892         isSrcOperand(int opIdx) override
52893         {
52894             switch (opIdx) {
52895               case 0: //src
52896                 return true;
52897               case 1: //vdst
52898                 return false;
52899               default:
52900                 fatal("op idx %i out of bounds\n", opIdx);
52901                 return false;
52902             }
52903         } // isSrcOperand
52904
52905         bool
52906         isDstOperand(int opIdx) override
52907         {
52908             switch (opIdx) {
52909               case 0: //src
52910                 return false;
52911               case 1: //vdst
52912                 return true;
52913               default:
52914                 fatal("op idx %i out of bounds\n", opIdx);
52915                 return false;
52916             }
52917         } // isDstOperand
52918
52919         void execute(GPUDynInstPtr) override;
52920     }; // Inst_VOP3__V_LOG_LEGACY_F32
52921
52922     class Inst_VOP3__V_MAD_LEGACY_F32 : public Inst_VOP3
52923     {
52924       public:
52925         Inst_VOP3__V_MAD_LEGACY_F32(InFmt_VOP3*);
52926         ~Inst_VOP3__V_MAD_LEGACY_F32();
52927
52928         int
52929         getNumOperands() override
52930         {
52931             return numDstRegOperands() + numSrcRegOperands();
52932         } // getNumOperands
52933
52934         int numDstRegOperands() override { return 1; }
52935         int numSrcRegOperands() override { return 3; }
52936
52937         int
52938         getOperandSize(int opIdx) override
52939         {
52940             switch (opIdx) {
52941               case 0: //src_0
52942                 return 4;
52943               case 1: //src_1
52944                 return 4;
52945               case 2: //src_2
52946                 return 4;
52947               case 3: //vdst
52948                 return 4;
52949               default:
52950                 fatal("op idx %i out of bounds\n", opIdx);
52951                 return -1;
52952             }
52953         } // getOperandSize
52954
52955         bool
52956         isSrcOperand(int opIdx) override
52957         {
52958             switch (opIdx) {
52959               case 0: //src_0
52960                 return true;
52961               case 1: //src_1
52962                 return true;
52963               case 2: //src_2
52964                 return true;
52965               case 3: //vdst
52966                 return false;
52967               default:
52968                 fatal("op idx %i out of bounds\n", opIdx);
52969                 return false;
52970             }
52971         } // isSrcOperand
52972
52973         bool
52974         isDstOperand(int opIdx) override
52975         {
52976             switch (opIdx) {
52977               case 0: //src_0
52978                 return false;
52979               case 1: //src_1
52980                 return false;
52981               case 2: //src_2
52982                 return false;
52983               case 3: //vdst
52984                 return true;
52985               default:
52986                 fatal("op idx %i out of bounds\n", opIdx);
52987                 return false;
52988             }
52989         } // isDstOperand
52990
52991         void execute(GPUDynInstPtr) override;
52992     }; // Inst_VOP3__V_MAD_LEGACY_F32
52993
52994     class Inst_VOP3__V_MAD_F32 : public Inst_VOP3
52995     {
52996       public:
52997         Inst_VOP3__V_MAD_F32(InFmt_VOP3*);
52998         ~Inst_VOP3__V_MAD_F32();
52999
53000         int
53001         getNumOperands() override
53002         {
53003             return numDstRegOperands() + numSrcRegOperands();
53004         } // getNumOperands
53005
53006         int numDstRegOperands() override { return 1; }
53007         int numSrcRegOperands() override { return 3; }
53008
53009         int
53010         getOperandSize(int opIdx) override
53011         {
53012             switch (opIdx) {
53013               case 0: //src_0
53014                 return 4;
53015               case 1: //src_1
53016                 return 4;
53017               case 2: //src_2
53018                 return 4;
53019               case 3: //vdst
53020                 return 4;
53021               default:
53022                 fatal("op idx %i out of bounds\n", opIdx);
53023                 return -1;
53024             }
53025         } // getOperandSize
53026
53027         bool
53028         isSrcOperand(int opIdx) override
53029         {
53030             switch (opIdx) {
53031               case 0: //src_0
53032                 return true;
53033               case 1: //src_1
53034                 return true;
53035               case 2: //src_2
53036                 return true;
53037               case 3: //vdst
53038                 return false;
53039               default:
53040                 fatal("op idx %i out of bounds\n", opIdx);
53041                 return false;
53042             }
53043         } // isSrcOperand
53044
53045         bool
53046         isDstOperand(int opIdx) override
53047         {
53048             switch (opIdx) {
53049               case 0: //src_0
53050                 return false;
53051               case 1: //src_1
53052                 return false;
53053               case 2: //src_2
53054                 return false;
53055               case 3: //vdst
53056                 return true;
53057               default:
53058                 fatal("op idx %i out of bounds\n", opIdx);
53059                 return false;
53060             }
53061         } // isDstOperand
53062
53063         void execute(GPUDynInstPtr) override;
53064     }; // Inst_VOP3__V_MAD_F32
53065
53066     class Inst_VOP3__V_MAD_I32_I24 : public Inst_VOP3
53067     {
53068       public:
53069         Inst_VOP3__V_MAD_I32_I24(InFmt_VOP3*);
53070         ~Inst_VOP3__V_MAD_I32_I24();
53071
53072         int
53073         getNumOperands() override
53074         {
53075             return numDstRegOperands() + numSrcRegOperands();
53076         } // getNumOperands
53077
53078         int numDstRegOperands() override { return 1; }
53079         int numSrcRegOperands() override { return 3; }
53080
53081         int
53082         getOperandSize(int opIdx) override
53083         {
53084             switch (opIdx) {
53085               case 0: //src_0
53086                 return 4;
53087               case 1: //src_1
53088                 return 4;
53089               case 2: //src_2
53090                 return 4;
53091               case 3: //vdst
53092                 return 4;
53093               default:
53094                 fatal("op idx %i out of bounds\n", opIdx);
53095                 return -1;
53096             }
53097         } // getOperandSize
53098
53099         bool
53100         isSrcOperand(int opIdx) override
53101         {
53102             switch (opIdx) {
53103               case 0: //src_0
53104                 return true;
53105               case 1: //src_1
53106                 return true;
53107               case 2: //src_2
53108                 return true;
53109               case 3: //vdst
53110                 return false;
53111               default:
53112                 fatal("op idx %i out of bounds\n", opIdx);
53113                 return false;
53114             }
53115         } // isSrcOperand
53116
53117         bool
53118         isDstOperand(int opIdx) override
53119         {
53120             switch (opIdx) {
53121               case 0: //src_0
53122                 return false;
53123               case 1: //src_1
53124                 return false;
53125               case 2: //src_2
53126                 return false;
53127               case 3: //vdst
53128                 return true;
53129               default:
53130                 fatal("op idx %i out of bounds\n", opIdx);
53131                 return false;
53132             }
53133         } // isDstOperand
53134
53135         void execute(GPUDynInstPtr) override;
53136     }; // Inst_VOP3__V_MAD_I32_I24
53137
53138     class Inst_VOP3__V_MAD_U32_U24 : public Inst_VOP3
53139     {
53140       public:
53141         Inst_VOP3__V_MAD_U32_U24(InFmt_VOP3*);
53142         ~Inst_VOP3__V_MAD_U32_U24();
53143
53144         int
53145         getNumOperands() override
53146         {
53147             return numDstRegOperands() + numSrcRegOperands();
53148         } // getNumOperands
53149
53150         int numDstRegOperands() override { return 1; }
53151         int numSrcRegOperands() override { return 3; }
53152
53153         int
53154         getOperandSize(int opIdx) override
53155         {
53156             switch (opIdx) {
53157               case 0: //src_0
53158                 return 4;
53159               case 1: //src_1
53160                 return 4;
53161               case 2: //src_2
53162                 return 4;
53163               case 3: //vdst
53164                 return 4;
53165               default:
53166                 fatal("op idx %i out of bounds\n", opIdx);
53167                 return -1;
53168             }
53169         } // getOperandSize
53170
53171         bool
53172         isSrcOperand(int opIdx) override
53173         {
53174             switch (opIdx) {
53175               case 0: //src_0
53176                 return true;
53177               case 1: //src_1
53178                 return true;
53179               case 2: //src_2
53180                 return true;
53181               case 3: //vdst
53182                 return false;
53183               default:
53184                 fatal("op idx %i out of bounds\n", opIdx);
53185                 return false;
53186             }
53187         } // isSrcOperand
53188
53189         bool
53190         isDstOperand(int opIdx) override
53191         {
53192             switch (opIdx) {
53193               case 0: //src_0
53194                 return false;
53195               case 1: //src_1
53196                 return false;
53197               case 2: //src_2
53198                 return false;
53199               case 3: //vdst
53200                 return true;
53201               default:
53202                 fatal("op idx %i out of bounds\n", opIdx);
53203                 return false;
53204             }
53205         } // isDstOperand
53206
53207         void execute(GPUDynInstPtr) override;
53208     }; // Inst_VOP3__V_MAD_U32_U24
53209
53210     class Inst_VOP3__V_CUBEID_F32 : public Inst_VOP3
53211     {
53212       public:
53213         Inst_VOP3__V_CUBEID_F32(InFmt_VOP3*);
53214         ~Inst_VOP3__V_CUBEID_F32();
53215
53216         int
53217         getNumOperands() override
53218         {
53219             return numDstRegOperands() + numSrcRegOperands();
53220         } // getNumOperands
53221
53222         int numDstRegOperands() override { return 1; }
53223         int numSrcRegOperands() override { return 3; }
53224
53225         int
53226         getOperandSize(int opIdx) override
53227         {
53228             switch (opIdx) {
53229               case 0: //src_0
53230                 return 4;
53231               case 1: //src_1
53232                 return 4;
53233               case 2: //src_2
53234                 return 4;
53235               case 3: //vdst
53236                 return 4;
53237               default:
53238                 fatal("op idx %i out of bounds\n", opIdx);
53239                 return -1;
53240             }
53241         } // getOperandSize
53242
53243         bool
53244         isSrcOperand(int opIdx) override
53245         {
53246             switch (opIdx) {
53247               case 0: //src_0
53248                 return true;
53249               case 1: //src_1
53250                 return true;
53251               case 2: //src_2
53252                 return true;
53253               case 3: //vdst
53254                 return false;
53255               default:
53256                 fatal("op idx %i out of bounds\n", opIdx);
53257                 return false;
53258             }
53259         } // isSrcOperand
53260
53261         bool
53262         isDstOperand(int opIdx) override
53263         {
53264             switch (opIdx) {
53265               case 0: //src_0
53266                 return false;
53267               case 1: //src_1
53268                 return false;
53269               case 2: //src_2
53270                 return false;
53271               case 3: //vdst
53272                 return true;
53273               default:
53274                 fatal("op idx %i out of bounds\n", opIdx);
53275                 return false;
53276             }
53277         } // isDstOperand
53278
53279         void execute(GPUDynInstPtr) override;
53280     }; // Inst_VOP3__V_CUBEID_F32
53281
53282     class Inst_VOP3__V_CUBESC_F32 : public Inst_VOP3
53283     {
53284       public:
53285         Inst_VOP3__V_CUBESC_F32(InFmt_VOP3*);
53286         ~Inst_VOP3__V_CUBESC_F32();
53287
53288         int
53289         getNumOperands() override
53290         {
53291             return numDstRegOperands() + numSrcRegOperands();
53292         } // getNumOperands
53293
53294         int numDstRegOperands() override { return 1; }
53295         int numSrcRegOperands() override { return 3; }
53296
53297         int
53298         getOperandSize(int opIdx) override
53299         {
53300             switch (opIdx) {
53301               case 0: //src_0
53302                 return 4;
53303               case 1: //src_1
53304                 return 4;
53305               case 2: //src_2
53306                 return 4;
53307               case 3: //vdst
53308                 return 4;
53309               default:
53310                 fatal("op idx %i out of bounds\n", opIdx);
53311                 return -1;
53312             }
53313         } // getOperandSize
53314
53315         bool
53316         isSrcOperand(int opIdx) override
53317         {
53318             switch (opIdx) {
53319               case 0: //src_0
53320                 return true;
53321               case 1: //src_1
53322                 return true;
53323               case 2: //src_2
53324                 return true;
53325               case 3: //vdst
53326                 return false;
53327               default:
53328                 fatal("op idx %i out of bounds\n", opIdx);
53329                 return false;
53330             }
53331         } // isSrcOperand
53332
53333         bool
53334         isDstOperand(int opIdx) override
53335         {
53336             switch (opIdx) {
53337               case 0: //src_0
53338                 return false;
53339               case 1: //src_1
53340                 return false;
53341               case 2: //src_2
53342                 return false;
53343               case 3: //vdst
53344                 return true;
53345               default:
53346                 fatal("op idx %i out of bounds\n", opIdx);
53347                 return false;
53348             }
53349         } // isDstOperand
53350
53351         void execute(GPUDynInstPtr) override;
53352     }; // Inst_VOP3__V_CUBESC_F32
53353
53354     class Inst_VOP3__V_CUBETC_F32 : public Inst_VOP3
53355     {
53356       public:
53357         Inst_VOP3__V_CUBETC_F32(InFmt_VOP3*);
53358         ~Inst_VOP3__V_CUBETC_F32();
53359
53360         int
53361         getNumOperands() override
53362         {
53363             return numDstRegOperands() + numSrcRegOperands();
53364         } // getNumOperands
53365
53366         int numDstRegOperands() override { return 1; }
53367         int numSrcRegOperands() override { return 3; }
53368
53369         int
53370         getOperandSize(int opIdx) override
53371         {
53372             switch (opIdx) {
53373               case 0: //src_0
53374                 return 4;
53375               case 1: //src_1
53376                 return 4;
53377               case 2: //src_2
53378                 return 4;
53379               case 3: //vdst
53380                 return 4;
53381               default:
53382                 fatal("op idx %i out of bounds\n", opIdx);
53383                 return -1;
53384             }
53385         } // getOperandSize
53386
53387         bool
53388         isSrcOperand(int opIdx) override
53389         {
53390             switch (opIdx) {
53391               case 0: //src_0
53392                 return true;
53393               case 1: //src_1
53394                 return true;
53395               case 2: //src_2
53396                 return true;
53397               case 3: //vdst
53398                 return false;
53399               default:
53400                 fatal("op idx %i out of bounds\n", opIdx);
53401                 return false;
53402             }
53403         } // isSrcOperand
53404
53405         bool
53406         isDstOperand(int opIdx) override
53407         {
53408             switch (opIdx) {
53409               case 0: //src_0
53410                 return false;
53411               case 1: //src_1
53412                 return false;
53413               case 2: //src_2
53414                 return false;
53415               case 3: //vdst
53416                 return true;
53417               default:
53418                 fatal("op idx %i out of bounds\n", opIdx);
53419                 return false;
53420             }
53421         } // isDstOperand
53422
53423         void execute(GPUDynInstPtr) override;
53424     }; // Inst_VOP3__V_CUBETC_F32
53425
53426     class Inst_VOP3__V_CUBEMA_F32 : public Inst_VOP3
53427     {
53428       public:
53429         Inst_VOP3__V_CUBEMA_F32(InFmt_VOP3*);
53430         ~Inst_VOP3__V_CUBEMA_F32();
53431
53432         int
53433         getNumOperands() override
53434         {
53435             return numDstRegOperands() + numSrcRegOperands();
53436         } // getNumOperands
53437
53438         int numDstRegOperands() override { return 1; }
53439         int numSrcRegOperands() override { return 3; }
53440
53441         int
53442         getOperandSize(int opIdx) override
53443         {
53444             switch (opIdx) {
53445               case 0: //src_0
53446                 return 4;
53447               case 1: //src_1
53448                 return 4;
53449               case 2: //src_2
53450                 return 4;
53451               case 3: //vdst
53452                 return 4;
53453               default:
53454                 fatal("op idx %i out of bounds\n", opIdx);
53455                 return -1;
53456             }
53457         } // getOperandSize
53458
53459         bool
53460         isSrcOperand(int opIdx) override
53461         {
53462             switch (opIdx) {
53463               case 0: //src_0
53464                 return true;
53465               case 1: //src_1
53466                 return true;
53467               case 2: //src_2
53468                 return true;
53469               case 3: //vdst
53470                 return false;
53471               default:
53472                 fatal("op idx %i out of bounds\n", opIdx);
53473                 return false;
53474             }
53475         } // isSrcOperand
53476
53477         bool
53478         isDstOperand(int opIdx) override
53479         {
53480             switch (opIdx) {
53481               case 0: //src_0
53482                 return false;
53483               case 1: //src_1
53484                 return false;
53485               case 2: //src_2
53486                 return false;
53487               case 3: //vdst
53488                 return true;
53489               default:
53490                 fatal("op idx %i out of bounds\n", opIdx);
53491                 return false;
53492             }
53493         } // isDstOperand
53494
53495         void execute(GPUDynInstPtr) override;
53496     }; // Inst_VOP3__V_CUBEMA_F32
53497
53498     class Inst_VOP3__V_BFE_U32 : public Inst_VOP3
53499     {
53500       public:
53501         Inst_VOP3__V_BFE_U32(InFmt_VOP3*);
53502         ~Inst_VOP3__V_BFE_U32();
53503
53504         int
53505         getNumOperands() override
53506         {
53507             return numDstRegOperands() + numSrcRegOperands();
53508         } // getNumOperands
53509
53510         int numDstRegOperands() override { return 1; }
53511         int numSrcRegOperands() override { return 3; }
53512
53513         int
53514         getOperandSize(int opIdx) override
53515         {
53516             switch (opIdx) {
53517               case 0: //src_0
53518                 return 4;
53519               case 1: //src_1
53520                 return 4;
53521               case 2: //src_2
53522                 return 4;
53523               case 3: //vdst
53524                 return 4;
53525               default:
53526                 fatal("op idx %i out of bounds\n", opIdx);
53527                 return -1;
53528             }
53529         } // getOperandSize
53530
53531         bool
53532         isSrcOperand(int opIdx) override
53533         {
53534             switch (opIdx) {
53535               case 0: //src_0
53536                 return true;
53537               case 1: //src_1
53538                 return true;
53539               case 2: //src_2
53540                 return true;
53541               case 3: //vdst
53542                 return false;
53543               default:
53544                 fatal("op idx %i out of bounds\n", opIdx);
53545                 return false;
53546             }
53547         } // isSrcOperand
53548
53549         bool
53550         isDstOperand(int opIdx) override
53551         {
53552             switch (opIdx) {
53553               case 0: //src_0
53554                 return false;
53555               case 1: //src_1
53556                 return false;
53557               case 2: //src_2
53558                 return false;
53559               case 3: //vdst
53560                 return true;
53561               default:
53562                 fatal("op idx %i out of bounds\n", opIdx);
53563                 return false;
53564             }
53565         } // isDstOperand
53566
53567         void execute(GPUDynInstPtr) override;
53568     }; // Inst_VOP3__V_BFE_U32
53569
53570     class Inst_VOP3__V_BFE_I32 : public Inst_VOP3
53571     {
53572       public:
53573         Inst_VOP3__V_BFE_I32(InFmt_VOP3*);
53574         ~Inst_VOP3__V_BFE_I32();
53575
53576         int
53577         getNumOperands() override
53578         {
53579             return numDstRegOperands() + numSrcRegOperands();
53580         } // getNumOperands
53581
53582         int numDstRegOperands() override { return 1; }
53583         int numSrcRegOperands() override { return 3; }
53584
53585         int
53586         getOperandSize(int opIdx) override
53587         {
53588             switch (opIdx) {
53589               case 0: //src_0
53590                 return 4;
53591               case 1: //src_1
53592                 return 4;
53593               case 2: //src_2
53594                 return 4;
53595               case 3: //vdst
53596                 return 4;
53597               default:
53598                 fatal("op idx %i out of bounds\n", opIdx);
53599                 return -1;
53600             }
53601         } // getOperandSize
53602
53603         bool
53604         isSrcOperand(int opIdx) override
53605         {
53606             switch (opIdx) {
53607               case 0: //src_0
53608                 return true;
53609               case 1: //src_1
53610                 return true;
53611               case 2: //src_2
53612                 return true;
53613               case 3: //vdst
53614                 return false;
53615               default:
53616                 fatal("op idx %i out of bounds\n", opIdx);
53617                 return false;
53618             }
53619         } // isSrcOperand
53620
53621         bool
53622         isDstOperand(int opIdx) override
53623         {
53624             switch (opIdx) {
53625               case 0: //src_0
53626                 return false;
53627               case 1: //src_1
53628                 return false;
53629               case 2: //src_2
53630                 return false;
53631               case 3: //vdst
53632                 return true;
53633               default:
53634                 fatal("op idx %i out of bounds\n", opIdx);
53635                 return false;
53636             }
53637         } // isDstOperand
53638
53639         void execute(GPUDynInstPtr) override;
53640     }; // Inst_VOP3__V_BFE_I32
53641
53642     class Inst_VOP3__V_BFI_B32 : public Inst_VOP3
53643     {
53644       public:
53645         Inst_VOP3__V_BFI_B32(InFmt_VOP3*);
53646         ~Inst_VOP3__V_BFI_B32();
53647
53648         int
53649         getNumOperands() override
53650         {
53651             return numDstRegOperands() + numSrcRegOperands();
53652         } // getNumOperands
53653
53654         int numDstRegOperands() override { return 1; }
53655         int numSrcRegOperands() override { return 3; }
53656
53657         int
53658         getOperandSize(int opIdx) override
53659         {
53660             switch (opIdx) {
53661               case 0: //src_0
53662                 return 4;
53663               case 1: //src_1
53664                 return 4;
53665               case 2: //src_2
53666                 return 4;
53667               case 3: //vdst
53668                 return 4;
53669               default:
53670                 fatal("op idx %i out of bounds\n", opIdx);
53671                 return -1;
53672             }
53673         } // getOperandSize
53674
53675         bool
53676         isSrcOperand(int opIdx) override
53677         {
53678             switch (opIdx) {
53679               case 0: //src_0
53680                 return true;
53681               case 1: //src_1
53682                 return true;
53683               case 2: //src_2
53684                 return true;
53685               case 3: //vdst
53686                 return false;
53687               default:
53688                 fatal("op idx %i out of bounds\n", opIdx);
53689                 return false;
53690             }
53691         } // isSrcOperand
53692
53693         bool
53694         isDstOperand(int opIdx) override
53695         {
53696             switch (opIdx) {
53697               case 0: //src_0
53698                 return false;
53699               case 1: //src_1
53700                 return false;
53701               case 2: //src_2
53702                 return false;
53703               case 3: //vdst
53704                 return true;
53705               default:
53706                 fatal("op idx %i out of bounds\n", opIdx);
53707                 return false;
53708             }
53709         } // isDstOperand
53710
53711         void execute(GPUDynInstPtr) override;
53712     }; // Inst_VOP3__V_BFI_B32
53713
53714     class Inst_VOP3__V_FMA_F32 : public Inst_VOP3
53715     {
53716       public:
53717         Inst_VOP3__V_FMA_F32(InFmt_VOP3*);
53718         ~Inst_VOP3__V_FMA_F32();
53719
53720         int
53721         getNumOperands() override
53722         {
53723             return numDstRegOperands() + numSrcRegOperands();
53724         } // getNumOperands
53725
53726         int numDstRegOperands() override { return 1; }
53727         int numSrcRegOperands() override { return 3; }
53728
53729         int
53730         getOperandSize(int opIdx) override
53731         {
53732             switch (opIdx) {
53733               case 0: //src_0
53734                 return 4;
53735               case 1: //src_1
53736                 return 4;
53737               case 2: //src_2
53738                 return 4;
53739               case 3: //vdst
53740                 return 4;
53741               default:
53742                 fatal("op idx %i out of bounds\n", opIdx);
53743                 return -1;
53744             }
53745         } // getOperandSize
53746
53747         bool
53748         isSrcOperand(int opIdx) override
53749         {
53750             switch (opIdx) {
53751               case 0: //src_0
53752                 return true;
53753               case 1: //src_1
53754                 return true;
53755               case 2: //src_2
53756                 return true;
53757               case 3: //vdst
53758                 return false;
53759               default:
53760                 fatal("op idx %i out of bounds\n", opIdx);
53761                 return false;
53762             }
53763         } // isSrcOperand
53764
53765         bool
53766         isDstOperand(int opIdx) override
53767         {
53768             switch (opIdx) {
53769               case 0: //src_0
53770                 return false;
53771               case 1: //src_1
53772                 return false;
53773               case 2: //src_2
53774                 return false;
53775               case 3: //vdst
53776                 return true;
53777               default:
53778                 fatal("op idx %i out of bounds\n", opIdx);
53779                 return false;
53780             }
53781         } // isDstOperand
53782
53783         void execute(GPUDynInstPtr) override;
53784     }; // Inst_VOP3__V_FMA_F32
53785
53786     class Inst_VOP3__V_FMA_F64 : public Inst_VOP3
53787     {
53788       public:
53789         Inst_VOP3__V_FMA_F64(InFmt_VOP3*);
53790         ~Inst_VOP3__V_FMA_F64();
53791
53792         int
53793         getNumOperands() override
53794         {
53795             return numDstRegOperands() + numSrcRegOperands();
53796         } // getNumOperands
53797
53798         int numDstRegOperands() override { return 1; }
53799         int numSrcRegOperands() override { return 3; }
53800
53801         int
53802         getOperandSize(int opIdx) override
53803         {
53804             switch (opIdx) {
53805               case 0: //src_0
53806                 return 8;
53807               case 1: //src_1
53808                 return 8;
53809               case 2: //src_2
53810                 return 8;
53811               case 3: //vdst
53812                 return 8;
53813               default:
53814                 fatal("op idx %i out of bounds\n", opIdx);
53815                 return -1;
53816             }
53817         } // getOperandSize
53818
53819         bool
53820         isSrcOperand(int opIdx) override
53821         {
53822             switch (opIdx) {
53823               case 0: //src_0
53824                 return true;
53825               case 1: //src_1
53826                 return true;
53827               case 2: //src_2
53828                 return true;
53829               case 3: //vdst
53830                 return false;
53831               default:
53832                 fatal("op idx %i out of bounds\n", opIdx);
53833                 return false;
53834             }
53835         } // isSrcOperand
53836
53837         bool
53838         isDstOperand(int opIdx) override
53839         {
53840             switch (opIdx) {
53841               case 0: //src_0
53842                 return false;
53843               case 1: //src_1
53844                 return false;
53845               case 2: //src_2
53846                 return false;
53847               case 3: //vdst
53848                 return true;
53849               default:
53850                 fatal("op idx %i out of bounds\n", opIdx);
53851                 return false;
53852             }
53853         } // isDstOperand
53854
53855         void execute(GPUDynInstPtr) override;
53856     }; // Inst_VOP3__V_FMA_F64
53857
53858     class Inst_VOP3__V_LERP_U8 : public Inst_VOP3
53859     {
53860       public:
53861         Inst_VOP3__V_LERP_U8(InFmt_VOP3*);
53862         ~Inst_VOP3__V_LERP_U8();
53863
53864         int
53865         getNumOperands() override
53866         {
53867             return numDstRegOperands() + numSrcRegOperands();
53868         } // getNumOperands
53869
53870         int numDstRegOperands() override { return 1; }
53871         int numSrcRegOperands() override { return 3; }
53872
53873         int
53874         getOperandSize(int opIdx) override
53875         {
53876             switch (opIdx) {
53877               case 0: //src_0
53878                 return 4;
53879               case 1: //src_1
53880                 return 4;
53881               case 2: //src_2
53882                 return 4;
53883               case 3: //vdst
53884                 return 4;
53885               default:
53886                 fatal("op idx %i out of bounds\n", opIdx);
53887                 return -1;
53888             }
53889         } // getOperandSize
53890
53891         bool
53892         isSrcOperand(int opIdx) override
53893         {
53894             switch (opIdx) {
53895               case 0: //src_0
53896                 return true;
53897               case 1: //src_1
53898                 return true;
53899               case 2: //src_2
53900                 return true;
53901               case 3: //vdst
53902                 return false;
53903               default:
53904                 fatal("op idx %i out of bounds\n", opIdx);
53905                 return false;
53906             }
53907         } // isSrcOperand
53908
53909         bool
53910         isDstOperand(int opIdx) override
53911         {
53912             switch (opIdx) {
53913               case 0: //src_0
53914                 return false;
53915               case 1: //src_1
53916                 return false;
53917               case 2: //src_2
53918                 return false;
53919               case 3: //vdst
53920                 return true;
53921               default:
53922                 fatal("op idx %i out of bounds\n", opIdx);
53923                 return false;
53924             }
53925         } // isDstOperand
53926
53927         void execute(GPUDynInstPtr) override;
53928     }; // Inst_VOP3__V_LERP_U8
53929
53930     class Inst_VOP3__V_ALIGNBIT_B32 : public Inst_VOP3
53931     {
53932       public:
53933         Inst_VOP3__V_ALIGNBIT_B32(InFmt_VOP3*);
53934         ~Inst_VOP3__V_ALIGNBIT_B32();
53935
53936         int
53937         getNumOperands() override
53938         {
53939             return numDstRegOperands() + numSrcRegOperands();
53940         } // getNumOperands
53941
53942         int numDstRegOperands() override { return 1; }
53943         int numSrcRegOperands() override { return 3; }
53944
53945         int
53946         getOperandSize(int opIdx) override
53947         {
53948             switch (opIdx) {
53949               case 0: //src_0
53950                 return 4;
53951               case 1: //src_1
53952                 return 4;
53953               case 2: //src_2
53954                 return 4;
53955               case 3: //vdst
53956                 return 4;
53957               default:
53958                 fatal("op idx %i out of bounds\n", opIdx);
53959                 return -1;
53960             }
53961         } // getOperandSize
53962
53963         bool
53964         isSrcOperand(int opIdx) override
53965         {
53966             switch (opIdx) {
53967               case 0: //src_0
53968                 return true;
53969               case 1: //src_1
53970                 return true;
53971               case 2: //src_2
53972                 return true;
53973               case 3: //vdst
53974                 return false;
53975               default:
53976                 fatal("op idx %i out of bounds\n", opIdx);
53977                 return false;
53978             }
53979         } // isSrcOperand
53980
53981         bool
53982         isDstOperand(int opIdx) override
53983         {
53984             switch (opIdx) {
53985               case 0: //src_0
53986                 return false;
53987               case 1: //src_1
53988                 return false;
53989               case 2: //src_2
53990                 return false;
53991               case 3: //vdst
53992                 return true;
53993               default:
53994                 fatal("op idx %i out of bounds\n", opIdx);
53995                 return false;
53996             }
53997         } // isDstOperand
53998
53999         void execute(GPUDynInstPtr) override;
54000     }; // Inst_VOP3__V_ALIGNBIT_B32
54001
54002     class Inst_VOP3__V_ALIGNBYTE_B32 : public Inst_VOP3
54003     {
54004       public:
54005         Inst_VOP3__V_ALIGNBYTE_B32(InFmt_VOP3*);
54006         ~Inst_VOP3__V_ALIGNBYTE_B32();
54007
54008         int
54009         getNumOperands() override
54010         {
54011             return numDstRegOperands() + numSrcRegOperands();
54012         } // getNumOperands
54013
54014         int numDstRegOperands() override { return 1; }
54015         int numSrcRegOperands() override { return 3; }
54016
54017         int
54018         getOperandSize(int opIdx) override
54019         {
54020             switch (opIdx) {
54021               case 0: //src_0
54022                 return 4;
54023               case 1: //src_1
54024                 return 4;
54025               case 2: //src_2
54026                 return 4;
54027               case 3: //vdst
54028                 return 4;
54029               default:
54030                 fatal("op idx %i out of bounds\n", opIdx);
54031                 return -1;
54032             }
54033         } // getOperandSize
54034
54035         bool
54036         isSrcOperand(int opIdx) override
54037         {
54038             switch (opIdx) {
54039               case 0: //src_0
54040                 return true;
54041               case 1: //src_1
54042                 return true;
54043               case 2: //src_2
54044                 return true;
54045               case 3: //vdst
54046                 return false;
54047               default:
54048                 fatal("op idx %i out of bounds\n", opIdx);
54049                 return false;
54050             }
54051         } // isSrcOperand
54052
54053         bool
54054         isDstOperand(int opIdx) override
54055         {
54056             switch (opIdx) {
54057               case 0: //src_0
54058                 return false;
54059               case 1: //src_1
54060                 return false;
54061               case 2: //src_2
54062                 return false;
54063               case 3: //vdst
54064                 return true;
54065               default:
54066                 fatal("op idx %i out of bounds\n", opIdx);
54067                 return false;
54068             }
54069         } // isDstOperand
54070
54071         void execute(GPUDynInstPtr) override;
54072     }; // Inst_VOP3__V_ALIGNBYTE_B32
54073
54074     class Inst_VOP3__V_MIN3_F32 : public Inst_VOP3
54075     {
54076       public:
54077         Inst_VOP3__V_MIN3_F32(InFmt_VOP3*);
54078         ~Inst_VOP3__V_MIN3_F32();
54079
54080         int
54081         getNumOperands() override
54082         {
54083             return numDstRegOperands() + numSrcRegOperands();
54084         } // getNumOperands
54085
54086         int numDstRegOperands() override { return 1; }
54087         int numSrcRegOperands() override { return 3; }
54088
54089         int
54090         getOperandSize(int opIdx) override
54091         {
54092             switch (opIdx) {
54093               case 0: //src_0
54094                 return 4;
54095               case 1: //src_1
54096                 return 4;
54097               case 2: //src_2
54098                 return 4;
54099               case 3: //vdst
54100                 return 4;
54101               default:
54102                 fatal("op idx %i out of bounds\n", opIdx);
54103                 return -1;
54104             }
54105         } // getOperandSize
54106
54107         bool
54108         isSrcOperand(int opIdx) override
54109         {
54110             switch (opIdx) {
54111               case 0: //src_0
54112                 return true;
54113               case 1: //src_1
54114                 return true;
54115               case 2: //src_2
54116                 return true;
54117               case 3: //vdst
54118                 return false;
54119               default:
54120                 fatal("op idx %i out of bounds\n", opIdx);
54121                 return false;
54122             }
54123         } // isSrcOperand
54124
54125         bool
54126         isDstOperand(int opIdx) override
54127         {
54128             switch (opIdx) {
54129               case 0: //src_0
54130                 return false;
54131               case 1: //src_1
54132                 return false;
54133               case 2: //src_2
54134                 return false;
54135               case 3: //vdst
54136                 return true;
54137               default:
54138                 fatal("op idx %i out of bounds\n", opIdx);
54139                 return false;
54140             }
54141         } // isDstOperand
54142
54143         void execute(GPUDynInstPtr) override;
54144     }; // Inst_VOP3__V_MIN3_F32
54145
54146     class Inst_VOP3__V_MIN3_I32 : public Inst_VOP3
54147     {
54148       public:
54149         Inst_VOP3__V_MIN3_I32(InFmt_VOP3*);
54150         ~Inst_VOP3__V_MIN3_I32();
54151
54152         int
54153         getNumOperands() override
54154         {
54155             return numDstRegOperands() + numSrcRegOperands();
54156         } // getNumOperands
54157
54158         int numDstRegOperands() override { return 1; }
54159         int numSrcRegOperands() override { return 3; }
54160
54161         int
54162         getOperandSize(int opIdx) override
54163         {
54164             switch (opIdx) {
54165               case 0: //src_0
54166                 return 4;
54167               case 1: //src_1
54168                 return 4;
54169               case 2: //src_2
54170                 return 4;
54171               case 3: //vdst
54172                 return 4;
54173               default:
54174                 fatal("op idx %i out of bounds\n", opIdx);
54175                 return -1;
54176             }
54177         } // getOperandSize
54178
54179         bool
54180         isSrcOperand(int opIdx) override
54181         {
54182             switch (opIdx) {
54183               case 0: //src_0
54184                 return true;
54185               case 1: //src_1
54186                 return true;
54187               case 2: //src_2
54188                 return true;
54189               case 3: //vdst
54190                 return false;
54191               default:
54192                 fatal("op idx %i out of bounds\n", opIdx);
54193                 return false;
54194             }
54195         } // isSrcOperand
54196
54197         bool
54198         isDstOperand(int opIdx) override
54199         {
54200             switch (opIdx) {
54201               case 0: //src_0
54202                 return false;
54203               case 1: //src_1
54204                 return false;
54205               case 2: //src_2
54206                 return false;
54207               case 3: //vdst
54208                 return true;
54209               default:
54210                 fatal("op idx %i out of bounds\n", opIdx);
54211                 return false;
54212             }
54213         } // isDstOperand
54214
54215         void execute(GPUDynInstPtr) override;
54216     }; // Inst_VOP3__V_MIN3_I32
54217
54218     class Inst_VOP3__V_MIN3_U32 : public Inst_VOP3
54219     {
54220       public:
54221         Inst_VOP3__V_MIN3_U32(InFmt_VOP3*);
54222         ~Inst_VOP3__V_MIN3_U32();
54223
54224         int
54225         getNumOperands() override
54226         {
54227             return numDstRegOperands() + numSrcRegOperands();
54228         } // getNumOperands
54229
54230         int numDstRegOperands() override { return 1; }
54231         int numSrcRegOperands() override { return 3; }
54232
54233         int
54234         getOperandSize(int opIdx) override
54235         {
54236             switch (opIdx) {
54237               case 0: //src_0
54238                 return 4;
54239               case 1: //src_1
54240                 return 4;
54241               case 2: //src_2
54242                 return 4;
54243               case 3: //vdst
54244                 return 4;
54245               default:
54246                 fatal("op idx %i out of bounds\n", opIdx);
54247                 return -1;
54248             }
54249         } // getOperandSize
54250
54251         bool
54252         isSrcOperand(int opIdx) override
54253         {
54254             switch (opIdx) {
54255               case 0: //src_0
54256                 return true;
54257               case 1: //src_1
54258                 return true;
54259               case 2: //src_2
54260                 return true;
54261               case 3: //vdst
54262                 return false;
54263               default:
54264                 fatal("op idx %i out of bounds\n", opIdx);
54265                 return false;
54266             }
54267         } // isSrcOperand
54268
54269         bool
54270         isDstOperand(int opIdx) override
54271         {
54272             switch (opIdx) {
54273               case 0: //src_0
54274                 return false;
54275               case 1: //src_1
54276                 return false;
54277               case 2: //src_2
54278                 return false;
54279               case 3: //vdst
54280                 return true;
54281               default:
54282                 fatal("op idx %i out of bounds\n", opIdx);
54283                 return false;
54284             }
54285         } // isDstOperand
54286
54287         void execute(GPUDynInstPtr) override;
54288     }; // Inst_VOP3__V_MIN3_U32
54289
54290     class Inst_VOP3__V_MAX3_F32 : public Inst_VOP3
54291     {
54292       public:
54293         Inst_VOP3__V_MAX3_F32(InFmt_VOP3*);
54294         ~Inst_VOP3__V_MAX3_F32();
54295
54296         int
54297         getNumOperands() override
54298         {
54299             return numDstRegOperands() + numSrcRegOperands();
54300         } // getNumOperands
54301
54302         int numDstRegOperands() override { return 1; }
54303         int numSrcRegOperands() override { return 3; }
54304
54305         int
54306         getOperandSize(int opIdx) override
54307         {
54308             switch (opIdx) {
54309               case 0: //src_0
54310                 return 4;
54311               case 1: //src_1
54312                 return 4;
54313               case 2: //src_2
54314                 return 4;
54315               case 3: //vdst
54316                 return 4;
54317               default:
54318                 fatal("op idx %i out of bounds\n", opIdx);
54319                 return -1;
54320             }
54321         } // getOperandSize
54322
54323         bool
54324         isSrcOperand(int opIdx) override
54325         {
54326             switch (opIdx) {
54327               case 0: //src_0
54328                 return true;
54329               case 1: //src_1
54330                 return true;
54331               case 2: //src_2
54332                 return true;
54333               case 3: //vdst
54334                 return false;
54335               default:
54336                 fatal("op idx %i out of bounds\n", opIdx);
54337                 return false;
54338             }
54339         } // isSrcOperand
54340
54341         bool
54342         isDstOperand(int opIdx) override
54343         {
54344             switch (opIdx) {
54345               case 0: //src_0
54346                 return false;
54347               case 1: //src_1
54348                 return false;
54349               case 2: //src_2
54350                 return false;
54351               case 3: //vdst
54352                 return true;
54353               default:
54354                 fatal("op idx %i out of bounds\n", opIdx);
54355                 return false;
54356             }
54357         } // isDstOperand
54358
54359         void execute(GPUDynInstPtr) override;
54360     }; // Inst_VOP3__V_MAX3_F32
54361
54362     class Inst_VOP3__V_MAX3_I32 : public Inst_VOP3
54363     {
54364       public:
54365         Inst_VOP3__V_MAX3_I32(InFmt_VOP3*);
54366         ~Inst_VOP3__V_MAX3_I32();
54367
54368         int
54369         getNumOperands() override
54370         {
54371             return numDstRegOperands() + numSrcRegOperands();
54372         } // getNumOperands
54373
54374         int numDstRegOperands() override { return 1; }
54375         int numSrcRegOperands() override { return 3; }
54376
54377         int
54378         getOperandSize(int opIdx) override
54379         {
54380             switch (opIdx) {
54381               case 0: //src_0
54382                 return 4;
54383               case 1: //src_1
54384                 return 4;
54385               case 2: //src_2
54386                 return 4;
54387               case 3: //vdst
54388                 return 4;
54389               default:
54390                 fatal("op idx %i out of bounds\n", opIdx);
54391                 return -1;
54392             }
54393         } // getOperandSize
54394
54395         bool
54396         isSrcOperand(int opIdx) override
54397         {
54398             switch (opIdx) {
54399               case 0: //src_0
54400                 return true;
54401               case 1: //src_1
54402                 return true;
54403               case 2: //src_2
54404                 return true;
54405               case 3: //vdst
54406                 return false;
54407               default:
54408                 fatal("op idx %i out of bounds\n", opIdx);
54409                 return false;
54410             }
54411         } // isSrcOperand
54412
54413         bool
54414         isDstOperand(int opIdx) override
54415         {
54416             switch (opIdx) {
54417               case 0: //src_0
54418                 return false;
54419               case 1: //src_1
54420                 return false;
54421               case 2: //src_2
54422                 return false;
54423               case 3: //vdst
54424                 return true;
54425               default:
54426                 fatal("op idx %i out of bounds\n", opIdx);
54427                 return false;
54428             }
54429         } // isDstOperand
54430
54431         void execute(GPUDynInstPtr) override;
54432     }; // Inst_VOP3__V_MAX3_I32
54433
54434     class Inst_VOP3__V_MAX3_U32 : public Inst_VOP3
54435     {
54436       public:
54437         Inst_VOP3__V_MAX3_U32(InFmt_VOP3*);
54438         ~Inst_VOP3__V_MAX3_U32();
54439
54440         int
54441         getNumOperands() override
54442         {
54443             return numDstRegOperands() + numSrcRegOperands();
54444         } // getNumOperands
54445
54446         int numDstRegOperands() override { return 1; }
54447         int numSrcRegOperands() override { return 3; }
54448
54449         int
54450         getOperandSize(int opIdx) override
54451         {
54452             switch (opIdx) {
54453               case 0: //src_0
54454                 return 4;
54455               case 1: //src_1
54456                 return 4;
54457               case 2: //src_2
54458                 return 4;
54459               case 3: //vdst
54460                 return 4;
54461               default:
54462                 fatal("op idx %i out of bounds\n", opIdx);
54463                 return -1;
54464             }
54465         } // getOperandSize
54466
54467         bool
54468         isSrcOperand(int opIdx) override
54469         {
54470             switch (opIdx) {
54471               case 0: //src_0
54472                 return true;
54473               case 1: //src_1
54474                 return true;
54475               case 2: //src_2
54476                 return true;
54477               case 3: //vdst
54478                 return false;
54479               default:
54480                 fatal("op idx %i out of bounds\n", opIdx);
54481                 return false;
54482             }
54483         } // isSrcOperand
54484
54485         bool
54486         isDstOperand(int opIdx) override
54487         {
54488             switch (opIdx) {
54489               case 0: //src_0
54490                 return false;
54491               case 1: //src_1
54492                 return false;
54493               case 2: //src_2
54494                 return false;
54495               case 3: //vdst
54496                 return true;
54497               default:
54498                 fatal("op idx %i out of bounds\n", opIdx);
54499                 return false;
54500             }
54501         } // isDstOperand
54502
54503         void execute(GPUDynInstPtr) override;
54504     }; // Inst_VOP3__V_MAX3_U32
54505
54506     class Inst_VOP3__V_MED3_F32 : public Inst_VOP3
54507     {
54508       public:
54509         Inst_VOP3__V_MED3_F32(InFmt_VOP3*);
54510         ~Inst_VOP3__V_MED3_F32();
54511
54512         int
54513         getNumOperands() override
54514         {
54515             return numDstRegOperands() + numSrcRegOperands();
54516         } // getNumOperands
54517
54518         int numDstRegOperands() override { return 1; }
54519         int numSrcRegOperands() override { return 3; }
54520
54521         int
54522         getOperandSize(int opIdx) override
54523         {
54524             switch (opIdx) {
54525               case 0: //src_0
54526                 return 4;
54527               case 1: //src_1
54528                 return 4;
54529               case 2: //src_2
54530                 return 4;
54531               case 3: //vdst
54532                 return 4;
54533               default:
54534                 fatal("op idx %i out of bounds\n", opIdx);
54535                 return -1;
54536             }
54537         } // getOperandSize
54538
54539         bool
54540         isSrcOperand(int opIdx) override
54541         {
54542             switch (opIdx) {
54543               case 0: //src_0
54544                 return true;
54545               case 1: //src_1
54546                 return true;
54547               case 2: //src_2
54548                 return true;
54549               case 3: //vdst
54550                 return false;
54551               default:
54552                 fatal("op idx %i out of bounds\n", opIdx);
54553                 return false;
54554             }
54555         } // isSrcOperand
54556
54557         bool
54558         isDstOperand(int opIdx) override
54559         {
54560             switch (opIdx) {
54561               case 0: //src_0
54562                 return false;
54563               case 1: //src_1
54564                 return false;
54565               case 2: //src_2
54566                 return false;
54567               case 3: //vdst
54568                 return true;
54569               default:
54570                 fatal("op idx %i out of bounds\n", opIdx);
54571                 return false;
54572             }
54573         } // isDstOperand
54574
54575         void execute(GPUDynInstPtr) override;
54576     }; // Inst_VOP3__V_MED3_F32
54577
54578     class Inst_VOP3__V_MED3_I32 : public Inst_VOP3
54579     {
54580       public:
54581         Inst_VOP3__V_MED3_I32(InFmt_VOP3*);
54582         ~Inst_VOP3__V_MED3_I32();
54583
54584         int
54585         getNumOperands() override
54586         {
54587             return numDstRegOperands() + numSrcRegOperands();
54588         } // getNumOperands
54589
54590         int numDstRegOperands() override { return 1; }
54591         int numSrcRegOperands() override { return 3; }
54592
54593         int
54594         getOperandSize(int opIdx) override
54595         {
54596             switch (opIdx) {
54597               case 0: //src_0
54598                 return 4;
54599               case 1: //src_1
54600                 return 4;
54601               case 2: //src_2
54602                 return 4;
54603               case 3: //vdst
54604                 return 4;
54605               default:
54606                 fatal("op idx %i out of bounds\n", opIdx);
54607                 return -1;
54608             }
54609         } // getOperandSize
54610
54611         bool
54612         isSrcOperand(int opIdx) override
54613         {
54614             switch (opIdx) {
54615               case 0: //src_0
54616                 return true;
54617               case 1: //src_1
54618                 return true;
54619               case 2: //src_2
54620                 return true;
54621               case 3: //vdst
54622                 return false;
54623               default:
54624                 fatal("op idx %i out of bounds\n", opIdx);
54625                 return false;
54626             }
54627         } // isSrcOperand
54628
54629         bool
54630         isDstOperand(int opIdx) override
54631         {
54632             switch (opIdx) {
54633               case 0: //src_0
54634                 return false;
54635               case 1: //src_1
54636                 return false;
54637               case 2: //src_2
54638                 return false;
54639               case 3: //vdst
54640                 return true;
54641               default:
54642                 fatal("op idx %i out of bounds\n", opIdx);
54643                 return false;
54644             }
54645         } // isDstOperand
54646
54647         void execute(GPUDynInstPtr) override;
54648     }; // Inst_VOP3__V_MED3_I32
54649
54650     class Inst_VOP3__V_MED3_U32 : public Inst_VOP3
54651     {
54652       public:
54653         Inst_VOP3__V_MED3_U32(InFmt_VOP3*);
54654         ~Inst_VOP3__V_MED3_U32();
54655
54656         int
54657         getNumOperands() override
54658         {
54659             return numDstRegOperands() + numSrcRegOperands();
54660         } // getNumOperands
54661
54662         int numDstRegOperands() override { return 1; }
54663         int numSrcRegOperands() override { return 3; }
54664
54665         int
54666         getOperandSize(int opIdx) override
54667         {
54668             switch (opIdx) {
54669               case 0: //src_0
54670                 return 4;
54671               case 1: //src_1
54672                 return 4;
54673               case 2: //src_2
54674                 return 4;
54675               case 3: //vdst
54676                 return 4;
54677               default:
54678                 fatal("op idx %i out of bounds\n", opIdx);
54679                 return -1;
54680             }
54681         } // getOperandSize
54682
54683         bool
54684         isSrcOperand(int opIdx) override
54685         {
54686             switch (opIdx) {
54687               case 0: //src_0
54688                 return true;
54689               case 1: //src_1
54690                 return true;
54691               case 2: //src_2
54692                 return true;
54693               case 3: //vdst
54694                 return false;
54695               default:
54696                 fatal("op idx %i out of bounds\n", opIdx);
54697                 return false;
54698             }
54699         } // isSrcOperand
54700
54701         bool
54702         isDstOperand(int opIdx) override
54703         {
54704             switch (opIdx) {
54705               case 0: //src_0
54706                 return false;
54707               case 1: //src_1
54708                 return false;
54709               case 2: //src_2
54710                 return false;
54711               case 3: //vdst
54712                 return true;
54713               default:
54714                 fatal("op idx %i out of bounds\n", opIdx);
54715                 return false;
54716             }
54717         } // isDstOperand
54718
54719         void execute(GPUDynInstPtr) override;
54720     }; // Inst_VOP3__V_MED3_U32
54721
54722     class Inst_VOP3__V_SAD_U8 : public Inst_VOP3
54723     {
54724       public:
54725         Inst_VOP3__V_SAD_U8(InFmt_VOP3*);
54726         ~Inst_VOP3__V_SAD_U8();
54727
54728         int
54729         getNumOperands() override
54730         {
54731             return numDstRegOperands() + numSrcRegOperands();
54732         } // getNumOperands
54733
54734         int numDstRegOperands() override { return 1; }
54735         int numSrcRegOperands() override { return 3; }
54736
54737         int
54738         getOperandSize(int opIdx) override
54739         {
54740             switch (opIdx) {
54741               case 0: //src_0
54742                 return 4;
54743               case 1: //src_1
54744                 return 4;
54745               case 2: //src_2
54746                 return 4;
54747               case 3: //vdst
54748                 return 4;
54749               default:
54750                 fatal("op idx %i out of bounds\n", opIdx);
54751                 return -1;
54752             }
54753         } // getOperandSize
54754
54755         bool
54756         isSrcOperand(int opIdx) override
54757         {
54758             switch (opIdx) {
54759               case 0: //src_0
54760                 return true;
54761               case 1: //src_1
54762                 return true;
54763               case 2: //src_2
54764                 return true;
54765               case 3: //vdst
54766                 return false;
54767               default:
54768                 fatal("op idx %i out of bounds\n", opIdx);
54769                 return false;
54770             }
54771         } // isSrcOperand
54772
54773         bool
54774         isDstOperand(int opIdx) override
54775         {
54776             switch (opIdx) {
54777               case 0: //src_0
54778                 return false;
54779               case 1: //src_1
54780                 return false;
54781               case 2: //src_2
54782                 return false;
54783               case 3: //vdst
54784                 return true;
54785               default:
54786                 fatal("op idx %i out of bounds\n", opIdx);
54787                 return false;
54788             }
54789         } // isDstOperand
54790
54791         void execute(GPUDynInstPtr) override;
54792     }; // Inst_VOP3__V_SAD_U8
54793
54794     class Inst_VOP3__V_SAD_HI_U8 : public Inst_VOP3
54795     {
54796       public:
54797         Inst_VOP3__V_SAD_HI_U8(InFmt_VOP3*);
54798         ~Inst_VOP3__V_SAD_HI_U8();
54799
54800         int
54801         getNumOperands() override
54802         {
54803             return numDstRegOperands() + numSrcRegOperands();
54804         } // getNumOperands
54805
54806         int numDstRegOperands() override { return 1; }
54807         int numSrcRegOperands() override { return 3; }
54808
54809         int
54810         getOperandSize(int opIdx) override
54811         {
54812             switch (opIdx) {
54813               case 0: //src_0
54814                 return 4;
54815               case 1: //src_1
54816                 return 4;
54817               case 2: //src_2
54818                 return 4;
54819               case 3: //vdst
54820                 return 4;
54821               default:
54822                 fatal("op idx %i out of bounds\n", opIdx);
54823                 return -1;
54824             }
54825         } // getOperandSize
54826
54827         bool
54828         isSrcOperand(int opIdx) override
54829         {
54830             switch (opIdx) {
54831               case 0: //src_0
54832                 return true;
54833               case 1: //src_1
54834                 return true;
54835               case 2: //src_2
54836                 return true;
54837               case 3: //vdst
54838                 return false;
54839               default:
54840                 fatal("op idx %i out of bounds\n", opIdx);
54841                 return false;
54842             }
54843         } // isSrcOperand
54844
54845         bool
54846         isDstOperand(int opIdx) override
54847         {
54848             switch (opIdx) {
54849               case 0: //src_0
54850                 return false;
54851               case 1: //src_1
54852                 return false;
54853               case 2: //src_2
54854                 return false;
54855               case 3: //vdst
54856                 return true;
54857               default:
54858                 fatal("op idx %i out of bounds\n", opIdx);
54859                 return false;
54860             }
54861         } // isDstOperand
54862
54863         void execute(GPUDynInstPtr) override;
54864     }; // Inst_VOP3__V_SAD_HI_U8
54865
54866     class Inst_VOP3__V_SAD_U16 : public Inst_VOP3
54867     {
54868       public:
54869         Inst_VOP3__V_SAD_U16(InFmt_VOP3*);
54870         ~Inst_VOP3__V_SAD_U16();
54871
54872         int
54873         getNumOperands() override
54874         {
54875             return numDstRegOperands() + numSrcRegOperands();
54876         } // getNumOperands
54877
54878         int numDstRegOperands() override { return 1; }
54879         int numSrcRegOperands() override { return 3; }
54880
54881         int
54882         getOperandSize(int opIdx) override
54883         {
54884             switch (opIdx) {
54885               case 0: //src_0
54886                 return 4;
54887               case 1: //src_1
54888                 return 4;
54889               case 2: //src_2
54890                 return 4;
54891               case 3: //vdst
54892                 return 4;
54893               default:
54894                 fatal("op idx %i out of bounds\n", opIdx);
54895                 return -1;
54896             }
54897         } // getOperandSize
54898
54899         bool
54900         isSrcOperand(int opIdx) override
54901         {
54902             switch (opIdx) {
54903               case 0: //src_0
54904                 return true;
54905               case 1: //src_1
54906                 return true;
54907               case 2: //src_2
54908                 return true;
54909               case 3: //vdst
54910                 return false;
54911               default:
54912                 fatal("op idx %i out of bounds\n", opIdx);
54913                 return false;
54914             }
54915         } // isSrcOperand
54916
54917         bool
54918         isDstOperand(int opIdx) override
54919         {
54920             switch (opIdx) {
54921               case 0: //src_0
54922                 return false;
54923               case 1: //src_1
54924                 return false;
54925               case 2: //src_2
54926                 return false;
54927               case 3: //vdst
54928                 return true;
54929               default:
54930                 fatal("op idx %i out of bounds\n", opIdx);
54931                 return false;
54932             }
54933         } // isDstOperand
54934
54935         void execute(GPUDynInstPtr) override;
54936     }; // Inst_VOP3__V_SAD_U16
54937
54938     class Inst_VOP3__V_SAD_U32 : public Inst_VOP3
54939     {
54940       public:
54941         Inst_VOP3__V_SAD_U32(InFmt_VOP3*);
54942         ~Inst_VOP3__V_SAD_U32();
54943
54944         int
54945         getNumOperands() override
54946         {
54947             return numDstRegOperands() + numSrcRegOperands();
54948         } // getNumOperands
54949
54950         int numDstRegOperands() override { return 1; }
54951         int numSrcRegOperands() override { return 3; }
54952
54953         int
54954         getOperandSize(int opIdx) override
54955         {
54956             switch (opIdx) {
54957               case 0: //src_0
54958                 return 4;
54959               case 1: //src_1
54960                 return 4;
54961               case 2: //src_2
54962                 return 4;
54963               case 3: //vdst
54964                 return 4;
54965               default:
54966                 fatal("op idx %i out of bounds\n", opIdx);
54967                 return -1;
54968             }
54969         } // getOperandSize
54970
54971         bool
54972         isSrcOperand(int opIdx) override
54973         {
54974             switch (opIdx) {
54975               case 0: //src_0
54976                 return true;
54977               case 1: //src_1
54978                 return true;
54979               case 2: //src_2
54980                 return true;
54981               case 3: //vdst
54982                 return false;
54983               default:
54984                 fatal("op idx %i out of bounds\n", opIdx);
54985                 return false;
54986             }
54987         } // isSrcOperand
54988
54989         bool
54990         isDstOperand(int opIdx) override
54991         {
54992             switch (opIdx) {
54993               case 0: //src_0
54994                 return false;
54995               case 1: //src_1
54996                 return false;
54997               case 2: //src_2
54998                 return false;
54999               case 3: //vdst
55000                 return true;
55001               default:
55002                 fatal("op idx %i out of bounds\n", opIdx);
55003                 return false;
55004             }
55005         } // isDstOperand
55006
55007         void execute(GPUDynInstPtr) override;
55008     }; // Inst_VOP3__V_SAD_U32
55009
55010     class Inst_VOP3__V_CVT_PK_U8_F32 : public Inst_VOP3
55011     {
55012       public:
55013         Inst_VOP3__V_CVT_PK_U8_F32(InFmt_VOP3*);
55014         ~Inst_VOP3__V_CVT_PK_U8_F32();
55015
55016         int
55017         getNumOperands() override
55018         {
55019             return numDstRegOperands() + numSrcRegOperands();
55020         } // getNumOperands
55021
55022         int numDstRegOperands() override { return 1; }
55023         int numSrcRegOperands() override { return 3; }
55024
55025         int
55026         getOperandSize(int opIdx) override
55027         {
55028             switch (opIdx) {
55029               case 0: //src_0
55030                 return 4;
55031               case 1: //src_1
55032                 return 4;
55033               case 2: //src_2
55034                 return 4;
55035               case 3: //vdst
55036                 return 4;
55037               default:
55038                 fatal("op idx %i out of bounds\n", opIdx);
55039                 return -1;
55040             }
55041         } // getOperandSize
55042
55043         bool
55044         isSrcOperand(int opIdx) override
55045         {
55046             switch (opIdx) {
55047               case 0: //src_0
55048                 return true;
55049               case 1: //src_1
55050                 return true;
55051               case 2: //src_2
55052                 return true;
55053               case 3: //vdst
55054                 return false;
55055               default:
55056                 fatal("op idx %i out of bounds\n", opIdx);
55057                 return false;
55058             }
55059         } // isSrcOperand
55060
55061         bool
55062         isDstOperand(int opIdx) override
55063         {
55064             switch (opIdx) {
55065               case 0: //src_0
55066                 return false;
55067               case 1: //src_1
55068                 return false;
55069               case 2: //src_2
55070                 return false;
55071               case 3: //vdst
55072                 return true;
55073               default:
55074                 fatal("op idx %i out of bounds\n", opIdx);
55075                 return false;
55076             }
55077         } // isDstOperand
55078
55079         void execute(GPUDynInstPtr) override;
55080     }; // Inst_VOP3__V_CVT_PK_U8_F32
55081
55082     class Inst_VOP3__V_DIV_FIXUP_F32 : public Inst_VOP3
55083     {
55084       public:
55085         Inst_VOP3__V_DIV_FIXUP_F32(InFmt_VOP3*);
55086         ~Inst_VOP3__V_DIV_FIXUP_F32();
55087
55088         int
55089         getNumOperands() override
55090         {
55091             return numDstRegOperands() + numSrcRegOperands();
55092         } // getNumOperands
55093
55094         int numDstRegOperands() override { return 1; }
55095         int numSrcRegOperands() override { return 3; }
55096
55097         int
55098         getOperandSize(int opIdx) override
55099         {
55100             switch (opIdx) {
55101               case 0: //src_0
55102                 return 4;
55103               case 1: //src_1
55104                 return 4;
55105               case 2: //src_2
55106                 return 4;
55107               case 3: //vdst
55108                 return 4;
55109               default:
55110                 fatal("op idx %i out of bounds\n", opIdx);
55111                 return -1;
55112             }
55113         } // getOperandSize
55114
55115         bool
55116         isSrcOperand(int opIdx) override
55117         {
55118             switch (opIdx) {
55119               case 0: //src_0
55120                 return true;
55121               case 1: //src_1
55122                 return true;
55123               case 2: //src_2
55124                 return true;
55125               case 3: //vdst
55126                 return false;
55127               default:
55128                 fatal("op idx %i out of bounds\n", opIdx);
55129                 return false;
55130             }
55131         } // isSrcOperand
55132
55133         bool
55134         isDstOperand(int opIdx) override
55135         {
55136             switch (opIdx) {
55137               case 0: //src_0
55138                 return false;
55139               case 1: //src_1
55140                 return false;
55141               case 2: //src_2
55142                 return false;
55143               case 3: //vdst
55144                 return true;
55145               default:
55146                 fatal("op idx %i out of bounds\n", opIdx);
55147                 return false;
55148             }
55149         } // isDstOperand
55150
55151         void execute(GPUDynInstPtr) override;
55152     }; // Inst_VOP3__V_DIV_FIXUP_F32
55153
55154     class Inst_VOP3__V_DIV_FIXUP_F64 : public Inst_VOP3
55155     {
55156       public:
55157         Inst_VOP3__V_DIV_FIXUP_F64(InFmt_VOP3*);
55158         ~Inst_VOP3__V_DIV_FIXUP_F64();
55159
55160         int
55161         getNumOperands() override
55162         {
55163             return numDstRegOperands() + numSrcRegOperands();
55164         } // getNumOperands
55165
55166         int numDstRegOperands() override { return 1; }
55167         int numSrcRegOperands() override { return 3; }
55168
55169         int
55170         getOperandSize(int opIdx) override
55171         {
55172             switch (opIdx) {
55173               case 0: //src_0
55174                 return 8;
55175               case 1: //src_1
55176                 return 8;
55177               case 2: //src_2
55178                 return 8;
55179               case 3: //vdst
55180                 return 8;
55181               default:
55182                 fatal("op idx %i out of bounds\n", opIdx);
55183                 return -1;
55184             }
55185         } // getOperandSize
55186
55187         bool
55188         isSrcOperand(int opIdx) override
55189         {
55190             switch (opIdx) {
55191               case 0: //src_0
55192                 return true;
55193               case 1: //src_1
55194                 return true;
55195               case 2: //src_2
55196                 return true;
55197               case 3: //vdst
55198                 return false;
55199               default:
55200                 fatal("op idx %i out of bounds\n", opIdx);
55201                 return false;
55202             }
55203         } // isSrcOperand
55204
55205         bool
55206         isDstOperand(int opIdx) override
55207         {
55208             switch (opIdx) {
55209               case 0: //src_0
55210                 return false;
55211               case 1: //src_1
55212                 return false;
55213               case 2: //src_2
55214                 return false;
55215               case 3: //vdst
55216                 return true;
55217               default:
55218                 fatal("op idx %i out of bounds\n", opIdx);
55219                 return false;
55220             }
55221         } // isDstOperand
55222
55223         void execute(GPUDynInstPtr) override;
55224     }; // Inst_VOP3__V_DIV_FIXUP_F64
55225
55226     class Inst_VOP3__V_DIV_SCALE_F32 : public Inst_VOP3_SDST_ENC
55227     {
55228       public:
55229         Inst_VOP3__V_DIV_SCALE_F32(InFmt_VOP3_SDST_ENC*);
55230         ~Inst_VOP3__V_DIV_SCALE_F32();
55231
55232         int
55233         getNumOperands() override
55234         {
55235             return numDstRegOperands() + numSrcRegOperands();
55236         } // getNumOperands
55237
55238         int numDstRegOperands() override { return 2; }
55239         int numSrcRegOperands() override { return 3; }
55240
55241         int
55242         getOperandSize(int opIdx) override
55243         {
55244             switch (opIdx) {
55245               case 0: //src_0
55246                 return 4;
55247               case 1: //src_1
55248                 return 4;
55249               case 2: //src_2
55250                 return 4;
55251               case 3: //vdst
55252                 return 4;
55253               case 4: //vcc
55254                 return 8;
55255               default:
55256                 fatal("op idx %i out of bounds\n", opIdx);
55257                 return -1;
55258             }
55259         } // getOperandSize
55260
55261         bool
55262         isSrcOperand(int opIdx) override
55263         {
55264             switch (opIdx) {
55265               case 0: //src_0
55266                 return true;
55267               case 1: //src_1
55268                 return true;
55269               case 2: //src_2
55270                 return true;
55271               case 3: //vdst
55272                 return false;
55273               case 4: //vcc
55274                 return false;
55275               default:
55276                 fatal("op idx %i out of bounds\n", opIdx);
55277                 return false;
55278             }
55279         } // isSrcOperand
55280
55281         bool
55282         isDstOperand(int opIdx) override
55283         {
55284             switch (opIdx) {
55285               case 0: //src_0
55286                 return false;
55287               case 1: //src_1
55288                 return false;
55289               case 2: //src_2
55290                 return false;
55291               case 3: //vdst
55292                 return true;
55293               case 4: //vcc
55294                 return true;
55295               default:
55296                 fatal("op idx %i out of bounds\n", opIdx);
55297                 return false;
55298             }
55299         } // isDstOperand
55300
55301         void execute(GPUDynInstPtr) override;
55302     }; // Inst_VOP3__V_DIV_SCALE_F32
55303
55304     class Inst_VOP3__V_DIV_SCALE_F64 : public Inst_VOP3_SDST_ENC
55305     {
55306       public:
55307         Inst_VOP3__V_DIV_SCALE_F64(InFmt_VOP3_SDST_ENC*);
55308         ~Inst_VOP3__V_DIV_SCALE_F64();
55309
55310         int
55311         getNumOperands() override
55312         {
55313             return numDstRegOperands() + numSrcRegOperands();
55314         } // getNumOperands
55315
55316         int numDstRegOperands() override { return 2; }
55317         int numSrcRegOperands() override { return 3; }
55318
55319         int
55320         getOperandSize(int opIdx) override
55321         {
55322             switch (opIdx) {
55323               case 0: //src_0
55324                 return 8;
55325               case 1: //src_1
55326                 return 8;
55327               case 2: //src_2
55328                 return 8;
55329               case 3: //vdst
55330                 return 8;
55331               case 4: //vcc
55332                 return 8;
55333               default:
55334                 fatal("op idx %i out of bounds\n", opIdx);
55335                 return -1;
55336             }
55337         } // getOperandSize
55338
55339         bool
55340         isSrcOperand(int opIdx) override
55341         {
55342             switch (opIdx) {
55343               case 0: //src_0
55344                 return true;
55345               case 1: //src_1
55346                 return true;
55347               case 2: //src_2
55348                 return true;
55349               case 3: //vdst
55350                 return false;
55351               case 4: //vcc
55352                 return false;
55353               default:
55354                 fatal("op idx %i out of bounds\n", opIdx);
55355                 return false;
55356             }
55357         } // isSrcOperand
55358
55359         bool
55360         isDstOperand(int opIdx) override
55361         {
55362             switch (opIdx) {
55363               case 0: //src_0
55364                 return false;
55365               case 1: //src_1
55366                 return false;
55367               case 2: //src_2
55368                 return false;
55369               case 3: //vdst
55370                 return true;
55371               case 4: //vcc
55372                 return true;
55373               default:
55374                 fatal("op idx %i out of bounds\n", opIdx);
55375                 return false;
55376             }
55377         } // isDstOperand
55378
55379         void execute(GPUDynInstPtr) override;
55380     }; // Inst_VOP3__V_DIV_SCALE_F64
55381
55382     class Inst_VOP3__V_DIV_FMAS_F32 : public Inst_VOP3
55383     {
55384       public:
55385         Inst_VOP3__V_DIV_FMAS_F32(InFmt_VOP3*);
55386         ~Inst_VOP3__V_DIV_FMAS_F32();
55387
55388         int
55389         getNumOperands() override
55390         {
55391             return numDstRegOperands() + numSrcRegOperands();
55392         } // getNumOperands
55393
55394         int numDstRegOperands() override { return 1; }
55395         int numSrcRegOperands() override { return 4; }
55396
55397         int
55398         getOperandSize(int opIdx) override
55399         {
55400             switch (opIdx) {
55401               case 0: //src_0
55402                 return 4;
55403               case 1: //src_1
55404                 return 4;
55405               case 2: //src_2
55406                 return 4;
55407               case 3:
55408                 return 8;
55409               case 4: //vdst
55410                 return 4;
55411               default:
55412                 fatal("op idx %i out of bounds\n", opIdx);
55413                 return -1;
55414             }
55415         } // getOperandSize
55416
55417         bool
55418         isSrcOperand(int opIdx) override
55419         {
55420             switch (opIdx) {
55421               case 0: //src_0
55422                 return true;
55423               case 1: //src_1
55424                 return true;
55425               case 2: //src_2
55426                 return true;
55427               case 3:
55428                 return true;
55429               case 4: //vdst
55430                 return false;
55431               default:
55432                 fatal("op idx %i out of bounds\n", opIdx);
55433                 return false;
55434             }
55435         } // isSrcOperand
55436
55437         bool
55438         isDstOperand(int opIdx) override
55439         {
55440             switch (opIdx) {
55441               case 0: //src_0
55442                 return false;
55443               case 1: //src_1
55444                 return false;
55445               case 2: //src_2
55446                 return false;
55447               case 3:
55448                 return false;
55449               case 4: //vdst
55450                 return true;
55451               default:
55452                 fatal("op idx %i out of bounds\n", opIdx);
55453                 return false;
55454             }
55455         } // isDstOperand
55456
55457         void execute(GPUDynInstPtr) override;
55458     }; // Inst_VOP3__V_DIV_FMAS_F32
55459
55460     class Inst_VOP3__V_DIV_FMAS_F64 : public Inst_VOP3
55461     {
55462       public:
55463         Inst_VOP3__V_DIV_FMAS_F64(InFmt_VOP3*);
55464         ~Inst_VOP3__V_DIV_FMAS_F64();
55465
55466         int
55467         getNumOperands() override
55468         {
55469             return numDstRegOperands() + numSrcRegOperands();
55470         } // getNumOperands
55471
55472         int numDstRegOperands() override { return 1; }
55473         int numSrcRegOperands() override { return 3; }
55474
55475         int
55476         getOperandSize(int opIdx) override
55477         {
55478             switch (opIdx) {
55479               case 0: //src_0
55480                 return 8;
55481               case 1: //src_1
55482                 return 8;
55483               case 2: //src_2
55484                 return 8;
55485               case 3: //vdst
55486                 return 8;
55487               default:
55488                 fatal("op idx %i out of bounds\n", opIdx);
55489                 return -1;
55490             }
55491         } // getOperandSize
55492
55493         bool
55494         isSrcOperand(int opIdx) override
55495         {
55496             switch (opIdx) {
55497               case 0: //src_0
55498                 return true;
55499               case 1: //src_1
55500                 return true;
55501               case 2: //src_2
55502                 return true;
55503               case 3: //vdst
55504                 return false;
55505               default:
55506                 fatal("op idx %i out of bounds\n", opIdx);
55507                 return false;
55508             }
55509         } // isSrcOperand
55510
55511         bool
55512         isDstOperand(int opIdx) override
55513         {
55514             switch (opIdx) {
55515               case 0: //src_0
55516                 return false;
55517               case 1: //src_1
55518                 return false;
55519               case 2: //src_2
55520                 return false;
55521               case 3: //vdst
55522                 return true;
55523               default:
55524                 fatal("op idx %i out of bounds\n", opIdx);
55525                 return false;
55526             }
55527         } // isDstOperand
55528
55529         void execute(GPUDynInstPtr) override;
55530     }; // Inst_VOP3__V_DIV_FMAS_F64
55531
55532     class Inst_VOP3__V_MSAD_U8 : public Inst_VOP3
55533     {
55534       public:
55535         Inst_VOP3__V_MSAD_U8(InFmt_VOP3*);
55536         ~Inst_VOP3__V_MSAD_U8();
55537
55538         int
55539         getNumOperands() override
55540         {
55541             return numDstRegOperands() + numSrcRegOperands();
55542         } // getNumOperands
55543
55544         int numDstRegOperands() override { return 1; }
55545         int numSrcRegOperands() override { return 3; }
55546
55547         int
55548         getOperandSize(int opIdx) override
55549         {
55550             switch (opIdx) {
55551               case 0: //src_0
55552                 return 4;
55553               case 1: //src_1
55554                 return 4;
55555               case 2: //src_2
55556                 return 4;
55557               case 3: //vdst
55558                 return 4;
55559               default:
55560                 fatal("op idx %i out of bounds\n", opIdx);
55561                 return -1;
55562             }
55563         } // getOperandSize
55564
55565         bool
55566         isSrcOperand(int opIdx) override
55567         {
55568             switch (opIdx) {
55569               case 0: //src_0
55570                 return true;
55571               case 1: //src_1
55572                 return true;
55573               case 2: //src_2
55574                 return true;
55575               case 3: //vdst
55576                 return false;
55577               default:
55578                 fatal("op idx %i out of bounds\n", opIdx);
55579                 return false;
55580             }
55581         } // isSrcOperand
55582
55583         bool
55584         isDstOperand(int opIdx) override
55585         {
55586             switch (opIdx) {
55587               case 0: //src_0
55588                 return false;
55589               case 1: //src_1
55590                 return false;
55591               case 2: //src_2
55592                 return false;
55593               case 3: //vdst
55594                 return true;
55595               default:
55596                 fatal("op idx %i out of bounds\n", opIdx);
55597                 return false;
55598             }
55599         } // isDstOperand
55600
55601         void execute(GPUDynInstPtr) override;
55602     }; // Inst_VOP3__V_MSAD_U8
55603
55604     class Inst_VOP3__V_QSAD_PK_U16_U8 : public Inst_VOP3
55605     {
55606       public:
55607         Inst_VOP3__V_QSAD_PK_U16_U8(InFmt_VOP3*);
55608         ~Inst_VOP3__V_QSAD_PK_U16_U8();
55609
55610         int
55611         getNumOperands() override
55612         {
55613             return numDstRegOperands() + numSrcRegOperands();
55614         } // getNumOperands
55615
55616         int numDstRegOperands() override { return 1; }
55617         int numSrcRegOperands() override { return 3; }
55618
55619         int
55620         getOperandSize(int opIdx) override
55621         {
55622             switch (opIdx) {
55623               case 0: //src_0
55624                 return 8;
55625               case 1: //src_1
55626                 return 4;
55627               case 2: //src_2
55628                 return 8;
55629               case 3: //vdst
55630                 return 8;
55631               default:
55632                 fatal("op idx %i out of bounds\n", opIdx);
55633                 return -1;
55634             }
55635         } // getOperandSize
55636
55637         bool
55638         isSrcOperand(int opIdx) override
55639         {
55640             switch (opIdx) {
55641               case 0: //src_0
55642                 return true;
55643               case 1: //src_1
55644                 return true;
55645               case 2: //src_2
55646                 return true;
55647               case 3: //vdst
55648                 return false;
55649               default:
55650                 fatal("op idx %i out of bounds\n", opIdx);
55651                 return false;
55652             }
55653         } // isSrcOperand
55654
55655         bool
55656         isDstOperand(int opIdx) override
55657         {
55658             switch (opIdx) {
55659               case 0: //src_0
55660                 return false;
55661               case 1: //src_1
55662                 return false;
55663               case 2: //src_2
55664                 return false;
55665               case 3: //vdst
55666                 return true;
55667               default:
55668                 fatal("op idx %i out of bounds\n", opIdx);
55669                 return false;
55670             }
55671         } // isDstOperand
55672
55673         void execute(GPUDynInstPtr) override;
55674     }; // Inst_VOP3__V_QSAD_PK_U16_U8
55675
55676     class Inst_VOP3__V_MQSAD_PK_U16_U8 : public Inst_VOP3
55677     {
55678       public:
55679         Inst_VOP3__V_MQSAD_PK_U16_U8(InFmt_VOP3*);
55680         ~Inst_VOP3__V_MQSAD_PK_U16_U8();
55681
55682         int
55683         getNumOperands() override
55684         {
55685             return numDstRegOperands() + numSrcRegOperands();
55686         } // getNumOperands
55687
55688         int numDstRegOperands() override { return 1; }
55689         int numSrcRegOperands() override { return 3; }
55690
55691         int
55692         getOperandSize(int opIdx) override
55693         {
55694             switch (opIdx) {
55695               case 0: //src_0
55696                 return 8;
55697               case 1: //src_1
55698                 return 4;
55699               case 2: //src_2
55700                 return 8;
55701               case 3: //vdst
55702                 return 8;
55703               default:
55704                 fatal("op idx %i out of bounds\n", opIdx);
55705                 return -1;
55706             }
55707         } // getOperandSize
55708
55709         bool
55710         isSrcOperand(int opIdx) override
55711         {
55712             switch (opIdx) {
55713               case 0: //src_0
55714                 return true;
55715               case 1: //src_1
55716                 return true;
55717               case 2: //src_2
55718                 return true;
55719               case 3: //vdst
55720                 return false;
55721               default:
55722                 fatal("op idx %i out of bounds\n", opIdx);
55723                 return false;
55724             }
55725         } // isSrcOperand
55726
55727         bool
55728         isDstOperand(int opIdx) override
55729         {
55730             switch (opIdx) {
55731               case 0: //src_0
55732                 return false;
55733               case 1: //src_1
55734                 return false;
55735               case 2: //src_2
55736                 return false;
55737               case 3: //vdst
55738                 return true;
55739               default:
55740                 fatal("op idx %i out of bounds\n", opIdx);
55741                 return false;
55742             }
55743         } // isDstOperand
55744
55745         void execute(GPUDynInstPtr) override;
55746     }; // Inst_VOP3__V_MQSAD_PK_U16_U8
55747
55748     class Inst_VOP3__V_MQSAD_U32_U8 : public Inst_VOP3
55749     {
55750       public:
55751         Inst_VOP3__V_MQSAD_U32_U8(InFmt_VOP3*);
55752         ~Inst_VOP3__V_MQSAD_U32_U8();
55753
55754         int
55755         getNumOperands() override
55756         {
55757             return numDstRegOperands() + numSrcRegOperands();
55758         } // getNumOperands
55759
55760         int numDstRegOperands() override { return 1; }
55761         int numSrcRegOperands() override { return 3; }
55762
55763         int
55764         getOperandSize(int opIdx) override
55765         {
55766             switch (opIdx) {
55767               case 0: //src_0
55768                 return 8;
55769               case 1: //src_1
55770                 return 4;
55771               case 2: //src_2
55772                 return 16;
55773               case 3: //vdst
55774                 return 16;
55775               default:
55776                 fatal("op idx %i out of bounds\n", opIdx);
55777                 return -1;
55778             }
55779         } // getOperandSize
55780
55781         bool
55782         isSrcOperand(int opIdx) override
55783         {
55784             switch (opIdx) {
55785               case 0: //src_0
55786                 return true;
55787               case 1: //src_1
55788                 return true;
55789               case 2: //src_2
55790                 return true;
55791               case 3: //vdst
55792                 return false;
55793               default:
55794                 fatal("op idx %i out of bounds\n", opIdx);
55795                 return false;
55796             }
55797         } // isSrcOperand
55798
55799         bool
55800         isDstOperand(int opIdx) override
55801         {
55802             switch (opIdx) {
55803               case 0: //src_0
55804                 return false;
55805               case 1: //src_1
55806                 return false;
55807               case 2: //src_2
55808                 return false;
55809               case 3: //vdst
55810                 return true;
55811               default:
55812                 fatal("op idx %i out of bounds\n", opIdx);
55813                 return false;
55814             }
55815         } // isDstOperand
55816
55817         void execute(GPUDynInstPtr) override;
55818     }; // Inst_VOP3__V_MQSAD_U32_U8
55819
55820     class Inst_VOP3__V_MAD_U64_U32 : public Inst_VOP3_SDST_ENC
55821     {
55822       public:
55823         Inst_VOP3__V_MAD_U64_U32(InFmt_VOP3_SDST_ENC*);
55824         ~Inst_VOP3__V_MAD_U64_U32();
55825
55826         int
55827         getNumOperands() override
55828         {
55829             return numDstRegOperands() + numSrcRegOperands();
55830         } // getNumOperands
55831
55832         int numDstRegOperands() override { return 2; }
55833         int numSrcRegOperands() override { return 3; }
55834
55835         int
55836         getOperandSize(int opIdx) override
55837         {
55838             switch (opIdx) {
55839               case 0: //src_0
55840                 return 4;
55841               case 1: //src_1
55842                 return 4;
55843               case 2: //src_2
55844                 return 4;
55845               case 3: //vdst
55846                 return 4;
55847               case 4: //carryout
55848                 return 8;
55849               default:
55850                 fatal("op idx %i out of bounds\n", opIdx);
55851                 return -1;
55852             }
55853         } // getOperandSize
55854
55855         bool
55856         isSrcOperand(int opIdx) override
55857         {
55858             switch (opIdx) {
55859               case 0: //src_0
55860                 return true;
55861               case 1: //src_1
55862                 return true;
55863               case 2: //src_2
55864                 return true;
55865               case 3: //vdst
55866                 return false;
55867               case 4: //carryout
55868                 return false;
55869               default:
55870                 fatal("op idx %i out of bounds\n", opIdx);
55871                 return false;
55872             }
55873         } // isSrcOperand
55874
55875         bool
55876         isDstOperand(int opIdx) override
55877         {
55878             switch (opIdx) {
55879               case 0: //src_0
55880                 return false;
55881               case 1: //src_1
55882                 return false;
55883               case 2: //src_2
55884                 return false;
55885               case 3: //vdst
55886                 return true;
55887               case 4: //carryout
55888                 return true;
55889               default:
55890                 fatal("op idx %i out of bounds\n", opIdx);
55891                 return false;
55892             }
55893         } // isDstOperand
55894
55895         void execute(GPUDynInstPtr) override;
55896     }; // Inst_VOP3__V_MAD_U64_U32
55897
55898     class Inst_VOP3__V_MAD_I64_I32 : public Inst_VOP3_SDST_ENC
55899     {
55900       public:
55901         Inst_VOP3__V_MAD_I64_I32(InFmt_VOP3_SDST_ENC*);
55902         ~Inst_VOP3__V_MAD_I64_I32();
55903
55904         int
55905         getNumOperands() override
55906         {
55907             return numDstRegOperands() + numSrcRegOperands();
55908         } // getNumOperands
55909
55910         int numDstRegOperands() override { return 2; }
55911         int numSrcRegOperands() override { return 3; }
55912
55913         int
55914         getOperandSize(int opIdx) override
55915         {
55916             switch (opIdx) {
55917               case 0: //src_0
55918                 return 4;
55919               case 1: //src_1
55920                 return 4;
55921               case 2: //src_2
55922                 return 4;
55923               case 3: //vdst
55924                 return 4;
55925               case 4: //carryout
55926                 return 8;
55927               default:
55928                 fatal("op idx %i out of bounds\n", opIdx);
55929                 return -1;
55930             }
55931         } // getOperandSize
55932
55933         bool
55934         isSrcOperand(int opIdx) override
55935         {
55936             switch (opIdx) {
55937               case 0: //src_0
55938                 return true;
55939               case 1: //src_1
55940                 return true;
55941               case 2: //src_2
55942                 return true;
55943               case 3: //vdst
55944                 return false;
55945               case 4: //carryout
55946                 return false;
55947               default:
55948                 fatal("op idx %i out of bounds\n", opIdx);
55949                 return false;
55950             }
55951         } // isSrcOperand
55952
55953         bool
55954         isDstOperand(int opIdx) override
55955         {
55956             switch (opIdx) {
55957               case 0: //src_0
55958                 return false;
55959               case 1: //src_1
55960                 return false;
55961               case 2: //src_2
55962                 return false;
55963               case 3: //vdst
55964                 return true;
55965               case 4: //carryout
55966                 return true;
55967               default:
55968                 fatal("op idx %i out of bounds\n", opIdx);
55969                 return false;
55970             }
55971         } // isDstOperand
55972
55973         void execute(GPUDynInstPtr) override;
55974     }; // Inst_VOP3__V_MAD_I64_I32
55975
55976     class Inst_VOP3__V_MAD_F16 : public Inst_VOP3
55977     {
55978       public:
55979         Inst_VOP3__V_MAD_F16(InFmt_VOP3*);
55980         ~Inst_VOP3__V_MAD_F16();
55981
55982         int
55983         getNumOperands() override
55984         {
55985             return numDstRegOperands() + numSrcRegOperands();
55986         } // getNumOperands
55987
55988         int numDstRegOperands() override { return 1; }
55989         int numSrcRegOperands() override { return 3; }
55990
55991         int
55992         getOperandSize(int opIdx) override
55993         {
55994             switch (opIdx) {
55995               case 0: //src_0
55996                 return 2;
55997               case 1: //src_1
55998                 return 2;
55999               case 2: //src_2
56000                 return 2;
56001               case 3: //vdst
56002                 return 2;
56003               default:
56004                 fatal("op idx %i out of bounds\n", opIdx);
56005                 return -1;
56006             }
56007         } // getOperandSize
56008
56009         bool
56010         isSrcOperand(int opIdx) override
56011         {
56012             switch (opIdx) {
56013               case 0: //src_0
56014                 return true;
56015               case 1: //src_1
56016                 return true;
56017               case 2: //src_2
56018                 return true;
56019               case 3: //vdst
56020                 return false;
56021               default:
56022                 fatal("op idx %i out of bounds\n", opIdx);
56023                 return false;
56024             }
56025         } // isSrcOperand
56026
56027         bool
56028         isDstOperand(int opIdx) override
56029         {
56030             switch (opIdx) {
56031               case 0: //src_0
56032                 return false;
56033               case 1: //src_1
56034                 return false;
56035               case 2: //src_2
56036                 return false;
56037               case 3: //vdst
56038                 return true;
56039               default:
56040                 fatal("op idx %i out of bounds\n", opIdx);
56041                 return false;
56042             }
56043         } // isDstOperand
56044
56045         void execute(GPUDynInstPtr) override;
56046     }; // Inst_VOP3__V_MAD_F16
56047
56048     class Inst_VOP3__V_MAD_U16 : public Inst_VOP3
56049     {
56050       public:
56051         Inst_VOP3__V_MAD_U16(InFmt_VOP3*);
56052         ~Inst_VOP3__V_MAD_U16();
56053
56054         int
56055         getNumOperands() override
56056         {
56057             return numDstRegOperands() + numSrcRegOperands();
56058         } // getNumOperands
56059
56060         int numDstRegOperands() override { return 1; }
56061         int numSrcRegOperands() override { return 3; }
56062
56063         int
56064         getOperandSize(int opIdx) override
56065         {
56066             switch (opIdx) {
56067               case 0: //src_0
56068                 return 2;
56069               case 1: //src_1
56070                 return 2;
56071               case 2: //src_2
56072                 return 2;
56073               case 3: //vdst
56074                 return 2;
56075               default:
56076                 fatal("op idx %i out of bounds\n", opIdx);
56077                 return -1;
56078             }
56079         } // getOperandSize
56080
56081         bool
56082         isSrcOperand(int opIdx) override
56083         {
56084             switch (opIdx) {
56085               case 0: //src_0
56086                 return true;
56087               case 1: //src_1
56088                 return true;
56089               case 2: //src_2
56090                 return true;
56091               case 3: //vdst
56092                 return false;
56093               default:
56094                 fatal("op idx %i out of bounds\n", opIdx);
56095                 return false;
56096             }
56097         } // isSrcOperand
56098
56099         bool
56100         isDstOperand(int opIdx) override
56101         {
56102             switch (opIdx) {
56103               case 0: //src_0
56104                 return false;
56105               case 1: //src_1
56106                 return false;
56107               case 2: //src_2
56108                 return false;
56109               case 3: //vdst
56110                 return true;
56111               default:
56112                 fatal("op idx %i out of bounds\n", opIdx);
56113                 return false;
56114             }
56115         } // isDstOperand
56116
56117         void execute(GPUDynInstPtr) override;
56118     }; // Inst_VOP3__V_MAD_U16
56119
56120     class Inst_VOP3__V_MAD_I16 : public Inst_VOP3
56121     {
56122       public:
56123         Inst_VOP3__V_MAD_I16(InFmt_VOP3*);
56124         ~Inst_VOP3__V_MAD_I16();
56125
56126         int
56127         getNumOperands() override
56128         {
56129             return numDstRegOperands() + numSrcRegOperands();
56130         } // getNumOperands
56131
56132         int numDstRegOperands() override { return 1; }
56133         int numSrcRegOperands() override { return 3; }
56134
56135         int
56136         getOperandSize(int opIdx) override
56137         {
56138             switch (opIdx) {
56139               case 0: //src_0
56140                 return 2;
56141               case 1: //src_1
56142                 return 2;
56143               case 2: //src_2
56144                 return 2;
56145               case 3: //vdst
56146                 return 2;
56147               default:
56148                 fatal("op idx %i out of bounds\n", opIdx);
56149                 return -1;
56150             }
56151         } // getOperandSize
56152
56153         bool
56154         isSrcOperand(int opIdx) override
56155         {
56156             switch (opIdx) {
56157               case 0: //src_0
56158                 return true;
56159               case 1: //src_1
56160                 return true;
56161               case 2: //src_2
56162                 return true;
56163               case 3: //vdst
56164                 return false;
56165               default:
56166                 fatal("op idx %i out of bounds\n", opIdx);
56167                 return false;
56168             }
56169         } // isSrcOperand
56170
56171         bool
56172         isDstOperand(int opIdx) override
56173         {
56174             switch (opIdx) {
56175               case 0: //src_0
56176                 return false;
56177               case 1: //src_1
56178                 return false;
56179               case 2: //src_2
56180                 return false;
56181               case 3: //vdst
56182                 return true;
56183               default:
56184                 fatal("op idx %i out of bounds\n", opIdx);
56185                 return false;
56186             }
56187         } // isDstOperand
56188
56189         void execute(GPUDynInstPtr) override;
56190     }; // Inst_VOP3__V_MAD_I16
56191
56192     class Inst_VOP3__V_PERM_B32 : public Inst_VOP3
56193     {
56194       public:
56195         Inst_VOP3__V_PERM_B32(InFmt_VOP3*);
56196         ~Inst_VOP3__V_PERM_B32();
56197
56198         int
56199         getNumOperands() override
56200         {
56201             return numDstRegOperands() + numSrcRegOperands();
56202         } // getNumOperands
56203
56204         int numDstRegOperands() override { return 1; }
56205         int numSrcRegOperands() override { return 3; }
56206
56207         int
56208         getOperandSize(int opIdx) override
56209         {
56210             switch (opIdx) {
56211               case 0: //src_0
56212                 return 4;
56213               case 1: //src_1
56214                 return 4;
56215               case 2: //src_2
56216                 return 4;
56217               case 3: //vdst
56218                 return 4;
56219               default:
56220                 fatal("op idx %i out of bounds\n", opIdx);
56221                 return -1;
56222             }
56223         } // getOperandSize
56224
56225         bool
56226         isSrcOperand(int opIdx) override
56227         {
56228             switch (opIdx) {
56229               case 0: //src_0
56230                 return true;
56231               case 1: //src_1
56232                 return true;
56233               case 2: //src_2
56234                 return true;
56235               case 3: //vdst
56236                 return false;
56237               default:
56238                 fatal("op idx %i out of bounds\n", opIdx);
56239                 return false;
56240             }
56241         } // isSrcOperand
56242
56243         bool
56244         isDstOperand(int opIdx) override
56245         {
56246             switch (opIdx) {
56247               case 0: //src_0
56248                 return false;
56249               case 1: //src_1
56250                 return false;
56251               case 2: //src_2
56252                 return false;
56253               case 3: //vdst
56254                 return true;
56255               default:
56256                 fatal("op idx %i out of bounds\n", opIdx);
56257                 return false;
56258             }
56259         } // isDstOperand
56260
56261         // From the GCN3 ISA SPEC:
56262         // byte permute(byte in[8], byte sel) {
56263         //     if (sel>=13) then return 0xff;
56264         //     elsif (sel==12) then return 0x00;
56265         //     elsif (sel==11) then return in[7][7] * 0xff;
56266         //     elsif (sel==10) then return in[5][7] * 0xff;
56267         //     elsif (sel==9) then return in[3][7] * 0xff;
56268         //     elsif (sel==8) then return in[1][7] * 0xff;
56269         //     else return in[sel];
56270         //     }
56271         // NOTE: I interpret the in[x][7] notation to mean "the high order
56272         // bit of byte x".
56273         uint8_t
56274         permute(uint64_t in_dword2x, uint32_t sel)
56275         {
56276             assert (sel < 256);
56277             uint8_t *in = reinterpret_cast<uint8_t*>(&in_dword2x);
56278             DPRINTF(GCN3, "in_dword2x = 0x%08x\n", in_dword2x);
56279             DPRINTF(GCN3, "Selecting %x using index %d\n", in[sel], sel);
56280             if (sel >= 13) return 0xFF;
56281             else if (sel == 12) return 0;
56282             else if (sel == 11) return (in[7] & 0x80) ? 0xFF : 0;
56283             else if (sel == 10) return (in[5] & 0x80) ? 0xFF : 0;
56284             else if (sel == 9) return (in[3] & 0x80) ? 0xFF : 0;
56285             else if (sel == 8) return (in[1] & 0x80) ? 0xFF : 0;
56286             else return in[sel];
56287         }
56288
56289         void execute(GPUDynInstPtr) override;
56290     }; // Inst_VOP3__V_PERM_B32
56291
56292     class Inst_VOP3__V_FMA_F16 : public Inst_VOP3
56293     {
56294       public:
56295         Inst_VOP3__V_FMA_F16(InFmt_VOP3*);
56296         ~Inst_VOP3__V_FMA_F16();
56297
56298         int
56299         getNumOperands() override
56300         {
56301             return numDstRegOperands() + numSrcRegOperands();
56302         } // getNumOperands
56303
56304         int numDstRegOperands() override { return 1; }
56305         int numSrcRegOperands() override { return 3; }
56306
56307         int
56308         getOperandSize(int opIdx) override
56309         {
56310             switch (opIdx) {
56311               case 0: //src_0
56312                 return 2;
56313               case 1: //src_1
56314                 return 2;
56315               case 2: //src_2
56316                 return 2;
56317               case 3: //vdst
56318                 return 2;
56319               default:
56320                 fatal("op idx %i out of bounds\n", opIdx);
56321                 return -1;
56322             }
56323         } // getOperandSize
56324
56325         bool
56326         isSrcOperand(int opIdx) override
56327         {
56328             switch (opIdx) {
56329               case 0: //src_0
56330                 return true;
56331               case 1: //src_1
56332                 return true;
56333               case 2: //src_2
56334                 return true;
56335               case 3: //vdst
56336                 return false;
56337               default:
56338                 fatal("op idx %i out of bounds\n", opIdx);
56339                 return false;
56340             }
56341         } // isSrcOperand
56342
56343         bool
56344         isDstOperand(int opIdx) override
56345         {
56346             switch (opIdx) {
56347               case 0: //src_0
56348                 return false;
56349               case 1: //src_1
56350                 return false;
56351               case 2: //src_2
56352                 return false;
56353               case 3: //vdst
56354                 return true;
56355               default:
56356                 fatal("op idx %i out of bounds\n", opIdx);
56357                 return false;
56358             }
56359         } // isDstOperand
56360
56361         void execute(GPUDynInstPtr) override;
56362     }; // Inst_VOP3__V_FMA_F16
56363
56364     class Inst_VOP3__V_DIV_FIXUP_F16 : public Inst_VOP3
56365     {
56366       public:
56367         Inst_VOP3__V_DIV_FIXUP_F16(InFmt_VOP3*);
56368         ~Inst_VOP3__V_DIV_FIXUP_F16();
56369
56370         int
56371         getNumOperands() override
56372         {
56373             return numDstRegOperands() + numSrcRegOperands();
56374         } // getNumOperands
56375
56376         int numDstRegOperands() override { return 1; }
56377         int numSrcRegOperands() override { return 3; }
56378
56379         int
56380         getOperandSize(int opIdx) override
56381         {
56382             switch (opIdx) {
56383               case 0: //src_0
56384                 return 2;
56385               case 1: //src_1
56386                 return 2;
56387               case 2: //src_2
56388                 return 2;
56389               case 3: //vdst
56390                 return 2;
56391               default:
56392                 fatal("op idx %i out of bounds\n", opIdx);
56393                 return -1;
56394             }
56395         } // getOperandSize
56396
56397         bool
56398         isSrcOperand(int opIdx) override
56399         {
56400             switch (opIdx) {
56401               case 0: //src_0
56402                 return true;
56403               case 1: //src_1
56404                 return true;
56405               case 2: //src_2
56406                 return true;
56407               case 3: //vdst
56408                 return false;
56409               default:
56410                 fatal("op idx %i out of bounds\n", opIdx);
56411                 return false;
56412             }
56413         } // isSrcOperand
56414
56415         bool
56416         isDstOperand(int opIdx) override
56417         {
56418             switch (opIdx) {
56419               case 0: //src_0
56420                 return false;
56421               case 1: //src_1
56422                 return false;
56423               case 2: //src_2
56424                 return false;
56425               case 3: //vdst
56426                 return true;
56427               default:
56428                 fatal("op idx %i out of bounds\n", opIdx);
56429                 return false;
56430             }
56431         } // isDstOperand
56432
56433         void execute(GPUDynInstPtr) override;
56434     }; // Inst_VOP3__V_DIV_FIXUP_F16
56435
56436     class Inst_VOP3__V_CVT_PKACCUM_U8_F32 : public Inst_VOP3
56437     {
56438       public:
56439         Inst_VOP3__V_CVT_PKACCUM_U8_F32(InFmt_VOP3*);
56440         ~Inst_VOP3__V_CVT_PKACCUM_U8_F32();
56441
56442         int
56443         getNumOperands() override
56444         {
56445             return numDstRegOperands() + numSrcRegOperands();
56446         } // getNumOperands
56447
56448         int numDstRegOperands() override { return 1; }
56449         int numSrcRegOperands() override { return 2; }
56450
56451         int
56452         getOperandSize(int opIdx) override
56453         {
56454             switch (opIdx) {
56455               case 0: //src_0
56456                 return 4;
56457               case 1: //src_1
56458                 return 4;
56459               case 2: //vdst
56460                 return 4;
56461               default:
56462                 fatal("op idx %i out of bounds\n", opIdx);
56463                 return -1;
56464             }
56465         } // getOperandSize
56466
56467         bool
56468         isSrcOperand(int opIdx) override
56469         {
56470             switch (opIdx) {
56471               case 0: //src_0
56472                 return true;
56473               case 1: //src_1
56474                 return true;
56475               case 2: //vdst
56476                 return false;
56477               default:
56478                 fatal("op idx %i out of bounds\n", opIdx);
56479                 return false;
56480             }
56481         } // isSrcOperand
56482
56483         bool
56484         isDstOperand(int opIdx) override
56485         {
56486             switch (opIdx) {
56487               case 0: //src_0
56488                 return false;
56489               case 1: //src_1
56490                 return false;
56491               case 2: //vdst
56492                 return true;
56493               default:
56494                 fatal("op idx %i out of bounds\n", opIdx);
56495                 return false;
56496             }
56497         } // isDstOperand
56498
56499         void execute(GPUDynInstPtr) override;
56500     }; // Inst_VOP3__V_CVT_PKACCUM_U8_F32
56501
56502     class Inst_VOP3__V_INTERP_P1_F32 : public Inst_VOP3
56503     {
56504       public:
56505         Inst_VOP3__V_INTERP_P1_F32(InFmt_VOP3*);
56506         ~Inst_VOP3__V_INTERP_P1_F32();
56507
56508         int
56509         getNumOperands() override
56510         {
56511             return numDstRegOperands() + numSrcRegOperands();
56512         } // getNumOperands
56513
56514         int numDstRegOperands() override { return 1; }
56515         int numSrcRegOperands() override { return 2; }
56516
56517         int
56518         getOperandSize(int opIdx) override
56519         {
56520             switch (opIdx) {
56521               case 0: //vgpr_ij
56522                 return 4;
56523               case 1: //attr
56524                 return 32;
56525               case 2: //vgpr_dst
56526                 return 4;
56527               default:
56528                 fatal("op idx %i out of bounds\n", opIdx);
56529                 return -1;
56530             }
56531         } // getOperandSize
56532
56533         bool
56534         isSrcOperand(int opIdx) override
56535         {
56536             switch (opIdx) {
56537               case 0: //vgpr_ij
56538                 return true;
56539               case 1: //attr
56540                 return true;
56541               case 2: //vgpr_dst
56542                 return false;
56543               default:
56544                 fatal("op idx %i out of bounds\n", opIdx);
56545                 return false;
56546             }
56547         } // isSrcOperand
56548
56549         bool
56550         isDstOperand(int opIdx) override
56551         {
56552             switch (opIdx) {
56553               case 0: //vgpr_ij
56554                 return false;
56555               case 1: //attr
56556                 return false;
56557               case 2: //vgpr_dst
56558                 return true;
56559               default:
56560                 fatal("op idx %i out of bounds\n", opIdx);
56561                 return false;
56562             }
56563         } // isDstOperand
56564
56565         void execute(GPUDynInstPtr) override;
56566     }; // Inst_VOP3__V_INTERP_P1_F32
56567
56568     class Inst_VOP3__V_INTERP_P2_F32 : public Inst_VOP3
56569     {
56570       public:
56571         Inst_VOP3__V_INTERP_P2_F32(InFmt_VOP3*);
56572         ~Inst_VOP3__V_INTERP_P2_F32();
56573
56574         int
56575         getNumOperands() override
56576         {
56577             return numDstRegOperands() + numSrcRegOperands();
56578         } // getNumOperands
56579
56580         int numDstRegOperands() override { return 1; }
56581         int numSrcRegOperands() override { return 2; }
56582
56583         int
56584         getOperandSize(int opIdx) override
56585         {
56586             switch (opIdx) {
56587               case 0: //vgpr_ij
56588                 return 4;
56589               case 1: //attr
56590                 return 32;
56591               case 2: //vgpr_dst
56592                 return 4;
56593               default:
56594                 fatal("op idx %i out of bounds\n", opIdx);
56595                 return -1;
56596             }
56597         } // getOperandSize
56598
56599         bool
56600         isSrcOperand(int opIdx) override
56601         {
56602             switch (opIdx) {
56603               case 0: //vgpr_ij
56604                 return true;
56605               case 1: //attr
56606                 return true;
56607               case 2: //vgpr_dst
56608                 return false;
56609               default:
56610                 fatal("op idx %i out of bounds\n", opIdx);
56611                 return false;
56612             }
56613         } // isSrcOperand
56614
56615         bool
56616         isDstOperand(int opIdx) override
56617         {
56618             switch (opIdx) {
56619               case 0: //vgpr_ij
56620                 return false;
56621               case 1: //attr
56622                 return false;
56623               case 2: //vgpr_dst
56624                 return true;
56625               default:
56626                 fatal("op idx %i out of bounds\n", opIdx);
56627                 return false;
56628             }
56629         } // isDstOperand
56630
56631         void execute(GPUDynInstPtr) override;
56632     }; // Inst_VOP3__V_INTERP_P2_F32
56633
56634     class Inst_VOP3__V_INTERP_MOV_F32 : public Inst_VOP3
56635     {
56636       public:
56637         Inst_VOP3__V_INTERP_MOV_F32(InFmt_VOP3*);
56638         ~Inst_VOP3__V_INTERP_MOV_F32();
56639
56640         int
56641         getNumOperands() override
56642         {
56643             return numDstRegOperands() + numSrcRegOperands();
56644         } // getNumOperands
56645
56646         int numDstRegOperands() override { return 1; }
56647         int numSrcRegOperands() override { return 2; }
56648
56649         int
56650         getOperandSize(int opIdx) override
56651         {
56652             switch (opIdx) {
56653               case 0: //param
56654                 return 4;
56655               case 1: //attr
56656                 return 32;
56657               case 2: //vgpr_dst
56658                 return 4;
56659               default:
56660                 fatal("op idx %i out of bounds\n", opIdx);
56661                 return -1;
56662             }
56663         } // getOperandSize
56664
56665         bool
56666         isSrcOperand(int opIdx) override
56667         {
56668             switch (opIdx) {
56669               case 0: //param
56670                 return true;
56671               case 1: //attr
56672                 return true;
56673               case 2: //vgpr_dst
56674                 return false;
56675               default:
56676                 fatal("op idx %i out of bounds\n", opIdx);
56677                 return false;
56678             }
56679         } // isSrcOperand
56680
56681         bool
56682         isDstOperand(int opIdx) override
56683         {
56684             switch (opIdx) {
56685               case 0: //param
56686                 return false;
56687               case 1: //attr
56688                 return false;
56689               case 2: //vgpr_dst
56690                 return true;
56691               default:
56692                 fatal("op idx %i out of bounds\n", opIdx);
56693                 return false;
56694             }
56695         } // isDstOperand
56696
56697         void execute(GPUDynInstPtr) override;
56698     }; // Inst_VOP3__V_INTERP_MOV_F32
56699
56700     class Inst_VOP3__V_INTERP_P1LL_F16 : public Inst_VOP3
56701     {
56702       public:
56703         Inst_VOP3__V_INTERP_P1LL_F16(InFmt_VOP3*);
56704         ~Inst_VOP3__V_INTERP_P1LL_F16();
56705
56706         int
56707         getNumOperands() override
56708         {
56709             return numDstRegOperands() + numSrcRegOperands();
56710         } // getNumOperands
56711
56712         int numDstRegOperands() override { return 1; }
56713         int numSrcRegOperands() override { return 2; }
56714
56715         int
56716         getOperandSize(int opIdx) override
56717         {
56718             switch (opIdx) {
56719               case 0: //vgpr_ij
56720                 return 4;
56721               case 1: //attr
56722                 return 2;
56723               case 2: //vgpr_dst
56724                 return 4;
56725               default:
56726                 fatal("op idx %i out of bounds\n", opIdx);
56727                 return -1;
56728             }
56729         } // getOperandSize
56730
56731         bool
56732         isSrcOperand(int opIdx) override
56733         {
56734             switch (opIdx) {
56735               case 0: //vgpr_ij
56736                 return true;
56737               case 1: //attr
56738                 return true;
56739               case 2: //vgpr_dst
56740                 return false;
56741               default:
56742                 fatal("op idx %i out of bounds\n", opIdx);
56743                 return false;
56744             }
56745         } // isSrcOperand
56746
56747         bool
56748         isDstOperand(int opIdx) override
56749         {
56750             switch (opIdx) {
56751               case 0: //vgpr_ij
56752                 return false;
56753               case 1: //attr
56754                 return false;
56755               case 2: //vgpr_dst
56756                 return true;
56757               default:
56758                 fatal("op idx %i out of bounds\n", opIdx);
56759                 return false;
56760             }
56761         } // isDstOperand
56762
56763         void execute(GPUDynInstPtr) override;
56764     }; // Inst_VOP3__V_INTERP_P1LL_F16
56765
56766     class Inst_VOP3__V_INTERP_P1LV_F16 : public Inst_VOP3
56767     {
56768       public:
56769         Inst_VOP3__V_INTERP_P1LV_F16(InFmt_VOP3*);
56770         ~Inst_VOP3__V_INTERP_P1LV_F16();
56771
56772         int
56773         getNumOperands() override
56774         {
56775             return numDstRegOperands() + numSrcRegOperands();
56776         } // getNumOperands
56777
56778         int numDstRegOperands() override { return 1; }
56779         int numSrcRegOperands() override { return 3; }
56780
56781         int
56782         getOperandSize(int opIdx) override
56783         {
56784             switch (opIdx) {
56785               case 0: //vgpr_ij
56786                 return 4;
56787               case 1: //attr
56788                 return 2;
56789               case 2: //vgpr_add
56790                 return 2;
56791               case 3: //vgpr_dst
56792                 return 4;
56793               default:
56794                 fatal("op idx %i out of bounds\n", opIdx);
56795                 return -1;
56796             }
56797         } // getOperandSize
56798
56799         bool
56800         isSrcOperand(int opIdx) override
56801         {
56802             switch (opIdx) {
56803               case 0: //vgpr_ij
56804                 return true;
56805               case 1: //attr
56806                 return true;
56807               case 2: //vgpr_add
56808                 return true;
56809               case 3: //vgpr_dst
56810                 return false;
56811               default:
56812                 fatal("op idx %i out of bounds\n", opIdx);
56813                 return false;
56814             }
56815         } // isSrcOperand
56816
56817         bool
56818         isDstOperand(int opIdx) override
56819         {
56820             switch (opIdx) {
56821               case 0: //vgpr_ij
56822                 return false;
56823               case 1: //attr
56824                 return false;
56825               case 2: //vgpr_add
56826                 return false;
56827               case 3: //vgpr_dst
56828                 return true;
56829               default:
56830                 fatal("op idx %i out of bounds\n", opIdx);
56831                 return false;
56832             }
56833         } // isDstOperand
56834
56835         void execute(GPUDynInstPtr) override;
56836     }; // Inst_VOP3__V_INTERP_P1LV_F16
56837
56838     class Inst_VOP3__V_INTERP_P2_F16 : public Inst_VOP3
56839     {
56840       public:
56841         Inst_VOP3__V_INTERP_P2_F16(InFmt_VOP3*);
56842         ~Inst_VOP3__V_INTERP_P2_F16();
56843
56844         int
56845         getNumOperands() override
56846         {
56847             return numDstRegOperands() + numSrcRegOperands();
56848         } // getNumOperands
56849
56850         int numDstRegOperands() override { return 1; }
56851         int numSrcRegOperands() override { return 3; }
56852
56853         int
56854         getOperandSize(int opIdx) override
56855         {
56856             switch (opIdx) {
56857               case 0: //vgpr_ij
56858                 return 4;
56859               case 1: //attr
56860                 return 2;
56861               case 2: //vgpr_add
56862                 return 4;
56863               case 3: //vgpr_dst
56864                 return 2;
56865               default:
56866                 fatal("op idx %i out of bounds\n", opIdx);
56867                 return -1;
56868             }
56869         } // getOperandSize
56870
56871         bool
56872         isSrcOperand(int opIdx) override
56873         {
56874             switch (opIdx) {
56875               case 0: //vgpr_ij
56876                 return true;
56877               case 1: //attr
56878                 return true;
56879               case 2: //vgpr_add
56880                 return true;
56881               case 3: //vgpr_dst
56882                 return false;
56883               default:
56884                 fatal("op idx %i out of bounds\n", opIdx);
56885                 return false;
56886             }
56887         } // isSrcOperand
56888
56889         bool
56890         isDstOperand(int opIdx) override
56891         {
56892             switch (opIdx) {
56893               case 0: //vgpr_ij
56894                 return false;
56895               case 1: //attr
56896                 return false;
56897               case 2: //vgpr_add
56898                 return false;
56899               case 3: //vgpr_dst
56900                 return true;
56901               default:
56902                 fatal("op idx %i out of bounds\n", opIdx);
56903                 return false;
56904             }
56905         } // isDstOperand
56906
56907         void execute(GPUDynInstPtr) override;
56908     }; // Inst_VOP3__V_INTERP_P2_F16
56909
56910     class Inst_VOP3__V_ADD_F64 : public Inst_VOP3
56911     {
56912       public:
56913         Inst_VOP3__V_ADD_F64(InFmt_VOP3*);
56914         ~Inst_VOP3__V_ADD_F64();
56915
56916         int
56917         getNumOperands() override
56918         {
56919             return numDstRegOperands() + numSrcRegOperands();
56920         } // getNumOperands
56921
56922         int numDstRegOperands() override { return 1; }
56923         int numSrcRegOperands() override { return 2; }
56924
56925         int
56926         getOperandSize(int opIdx) override
56927         {
56928             switch (opIdx) {
56929               case 0: //src_0
56930                 return 8;
56931               case 1: //src_1
56932                 return 8;
56933               case 2: //vdst
56934                 return 8;
56935               default:
56936                 fatal("op idx %i out of bounds\n", opIdx);
56937                 return -1;
56938             }
56939         } // getOperandSize
56940
56941         bool
56942         isSrcOperand(int opIdx) override
56943         {
56944             switch (opIdx) {
56945               case 0: //src_0
56946                 return true;
56947               case 1: //src_1
56948                 return true;
56949               case 2: //vdst
56950                 return false;
56951               default:
56952                 fatal("op idx %i out of bounds\n", opIdx);
56953                 return false;
56954             }
56955         } // isSrcOperand
56956
56957         bool
56958         isDstOperand(int opIdx) override
56959         {
56960             switch (opIdx) {
56961               case 0: //src_0
56962                 return false;
56963               case 1: //src_1
56964                 return false;
56965               case 2: //vdst
56966                 return true;
56967               default:
56968                 fatal("op idx %i out of bounds\n", opIdx);
56969                 return false;
56970             }
56971         } // isDstOperand
56972
56973         void execute(GPUDynInstPtr) override;
56974     }; // Inst_VOP3__V_ADD_F64
56975
56976     class Inst_VOP3__V_MUL_F64 : public Inst_VOP3
56977     {
56978       public:
56979         Inst_VOP3__V_MUL_F64(InFmt_VOP3*);
56980         ~Inst_VOP3__V_MUL_F64();
56981
56982         int
56983         getNumOperands() override
56984         {
56985             return numDstRegOperands() + numSrcRegOperands();
56986         } // getNumOperands
56987
56988         int numDstRegOperands() override { return 1; }
56989         int numSrcRegOperands() override { return 2; }
56990
56991         int
56992         getOperandSize(int opIdx) override
56993         {
56994             switch (opIdx) {
56995               case 0: //src_0
56996                 return 8;
56997               case 1: //src_1
56998                 return 8;
56999               case 2: //vdst
57000                 return 8;
57001               default:
57002                 fatal("op idx %i out of bounds\n", opIdx);
57003                 return -1;
57004             }
57005         } // getOperandSize
57006
57007         bool
57008         isSrcOperand(int opIdx) override
57009         {
57010             switch (opIdx) {
57011               case 0: //src_0
57012                 return true;
57013               case 1: //src_1
57014                 return true;
57015               case 2: //vdst
57016                 return false;
57017               default:
57018                 fatal("op idx %i out of bounds\n", opIdx);
57019                 return false;
57020             }
57021         } // isSrcOperand
57022
57023         bool
57024         isDstOperand(int opIdx) override
57025         {
57026             switch (opIdx) {
57027               case 0: //src_0
57028                 return false;
57029               case 1: //src_1
57030                 return false;
57031               case 2: //vdst
57032                 return true;
57033               default:
57034                 fatal("op idx %i out of bounds\n", opIdx);
57035                 return false;
57036             }
57037         } // isDstOperand
57038
57039         void execute(GPUDynInstPtr) override;
57040     }; // Inst_VOP3__V_MUL_F64
57041
57042     class Inst_VOP3__V_MIN_F64 : public Inst_VOP3
57043     {
57044       public:
57045         Inst_VOP3__V_MIN_F64(InFmt_VOP3*);
57046         ~Inst_VOP3__V_MIN_F64();
57047
57048         int
57049         getNumOperands() override
57050         {
57051             return numDstRegOperands() + numSrcRegOperands();
57052         } // getNumOperands
57053
57054         int numDstRegOperands() override { return 1; }
57055         int numSrcRegOperands() override { return 2; }
57056
57057         int
57058         getOperandSize(int opIdx) override
57059         {
57060             switch (opIdx) {
57061               case 0: //src_0
57062                 return 8;
57063               case 1: //src_1
57064                 return 8;
57065               case 2: //vdst
57066                 return 8;
57067               default:
57068                 fatal("op idx %i out of bounds\n", opIdx);
57069                 return -1;
57070             }
57071         } // getOperandSize
57072
57073         bool
57074         isSrcOperand(int opIdx) override
57075         {
57076             switch (opIdx) {
57077               case 0: //src_0
57078                 return true;
57079               case 1: //src_1
57080                 return true;
57081               case 2: //vdst
57082                 return false;
57083               default:
57084                 fatal("op idx %i out of bounds\n", opIdx);
57085                 return false;
57086             }
57087         } // isSrcOperand
57088
57089         bool
57090         isDstOperand(int opIdx) override
57091         {
57092             switch (opIdx) {
57093               case 0: //src_0
57094                 return false;
57095               case 1: //src_1
57096                 return false;
57097               case 2: //vdst
57098                 return true;
57099               default:
57100                 fatal("op idx %i out of bounds\n", opIdx);
57101                 return false;
57102             }
57103         } // isDstOperand
57104
57105         void execute(GPUDynInstPtr) override;
57106     }; // Inst_VOP3__V_MIN_F64
57107
57108     class Inst_VOP3__V_MAX_F64 : public Inst_VOP3
57109     {
57110       public:
57111         Inst_VOP3__V_MAX_F64(InFmt_VOP3*);
57112         ~Inst_VOP3__V_MAX_F64();
57113
57114         int
57115         getNumOperands() override
57116         {
57117             return numDstRegOperands() + numSrcRegOperands();
57118         } // getNumOperands
57119
57120         int numDstRegOperands() override { return 1; }
57121         int numSrcRegOperands() override { return 2; }
57122
57123         int
57124         getOperandSize(int opIdx) override
57125         {
57126             switch (opIdx) {
57127               case 0: //src_0
57128                 return 8;
57129               case 1: //src_1
57130                 return 8;
57131               case 2: //vdst
57132                 return 8;
57133               default:
57134                 fatal("op idx %i out of bounds\n", opIdx);
57135                 return -1;
57136             }
57137         } // getOperandSize
57138
57139         bool
57140         isSrcOperand(int opIdx) override
57141         {
57142             switch (opIdx) {
57143               case 0: //src_0
57144                 return true;
57145               case 1: //src_1
57146                 return true;
57147               case 2: //vdst
57148                 return false;
57149               default:
57150                 fatal("op idx %i out of bounds\n", opIdx);
57151                 return false;
57152             }
57153         } // isSrcOperand
57154
57155         bool
57156         isDstOperand(int opIdx) override
57157         {
57158             switch (opIdx) {
57159               case 0: //src_0
57160                 return false;
57161               case 1: //src_1
57162                 return false;
57163               case 2: //vdst
57164                 return true;
57165               default:
57166                 fatal("op idx %i out of bounds\n", opIdx);
57167                 return false;
57168             }
57169         } // isDstOperand
57170
57171         void execute(GPUDynInstPtr) override;
57172     }; // Inst_VOP3__V_MAX_F64
57173
57174     class Inst_VOP3__V_LDEXP_F64 : public Inst_VOP3
57175     {
57176       public:
57177         Inst_VOP3__V_LDEXP_F64(InFmt_VOP3*);
57178         ~Inst_VOP3__V_LDEXP_F64();
57179
57180         int
57181         getNumOperands() override
57182         {
57183             return numDstRegOperands() + numSrcRegOperands();
57184         } // getNumOperands
57185
57186         int numDstRegOperands() override { return 1; }
57187         int numSrcRegOperands() override { return 2; }
57188
57189         int
57190         getOperandSize(int opIdx) override
57191         {
57192             switch (opIdx) {
57193               case 0: //src_0
57194                 return 8;
57195               case 1: //src_1
57196                 return 4;
57197               case 2: //vdst
57198                 return 8;
57199               default:
57200                 fatal("op idx %i out of bounds\n", opIdx);
57201                 return -1;
57202             }
57203         } // getOperandSize
57204
57205         bool
57206         isSrcOperand(int opIdx) override
57207         {
57208             switch (opIdx) {
57209               case 0: //src_0
57210                 return true;
57211               case 1: //src_1
57212                 return true;
57213               case 2: //vdst
57214                 return false;
57215               default:
57216                 fatal("op idx %i out of bounds\n", opIdx);
57217                 return false;
57218             }
57219         } // isSrcOperand
57220
57221         bool
57222         isDstOperand(int opIdx) override
57223         {
57224             switch (opIdx) {
57225               case 0: //src_0
57226                 return false;
57227               case 1: //src_1
57228                 return false;
57229               case 2: //vdst
57230                 return true;
57231               default:
57232                 fatal("op idx %i out of bounds\n", opIdx);
57233                 return false;
57234             }
57235         } // isDstOperand
57236
57237         void execute(GPUDynInstPtr) override;
57238     }; // Inst_VOP3__V_LDEXP_F64
57239
57240     class Inst_VOP3__V_MUL_LO_U32 : public Inst_VOP3
57241     {
57242       public:
57243         Inst_VOP3__V_MUL_LO_U32(InFmt_VOP3*);
57244         ~Inst_VOP3__V_MUL_LO_U32();
57245
57246         int
57247         getNumOperands() override
57248         {
57249             return numDstRegOperands() + numSrcRegOperands();
57250         } // getNumOperands
57251
57252         int numDstRegOperands() override { return 1; }
57253         int numSrcRegOperands() override { return 2; }
57254
57255         int
57256         getOperandSize(int opIdx) override
57257         {
57258             switch (opIdx) {
57259               case 0: //src_0
57260                 return 4;
57261               case 1: //src_1
57262                 return 4;
57263               case 2: //vdst
57264                 return 4;
57265               default:
57266                 fatal("op idx %i out of bounds\n", opIdx);
57267                 return -1;
57268             }
57269         } // getOperandSize
57270
57271         bool
57272         isSrcOperand(int opIdx) override
57273         {
57274             switch (opIdx) {
57275               case 0: //src_0
57276                 return true;
57277               case 1: //src_1
57278                 return true;
57279               case 2: //vdst
57280                 return false;
57281               default:
57282                 fatal("op idx %i out of bounds\n", opIdx);
57283                 return false;
57284             }
57285         } // isSrcOperand
57286
57287         bool
57288         isDstOperand(int opIdx) override
57289         {
57290             switch (opIdx) {
57291               case 0: //src_0
57292                 return false;
57293               case 1: //src_1
57294                 return false;
57295               case 2: //vdst
57296                 return true;
57297               default:
57298                 fatal("op idx %i out of bounds\n", opIdx);
57299                 return false;
57300             }
57301         } // isDstOperand
57302
57303         void execute(GPUDynInstPtr) override;
57304     }; // Inst_VOP3__V_MUL_LO_U32
57305
57306     class Inst_VOP3__V_MUL_HI_U32 : public Inst_VOP3
57307     {
57308       public:
57309         Inst_VOP3__V_MUL_HI_U32(InFmt_VOP3*);
57310         ~Inst_VOP3__V_MUL_HI_U32();
57311
57312         int
57313         getNumOperands() override
57314         {
57315             return numDstRegOperands() + numSrcRegOperands();
57316         } // getNumOperands
57317
57318         int numDstRegOperands() override { return 1; }
57319         int numSrcRegOperands() override { return 2; }
57320
57321         int
57322         getOperandSize(int opIdx) override
57323         {
57324             switch (opIdx) {
57325               case 0: //src_0
57326                 return 4;
57327               case 1: //src_1
57328                 return 4;
57329               case 2: //vdst
57330                 return 4;
57331               default:
57332                 fatal("op idx %i out of bounds\n", opIdx);
57333                 return -1;
57334             }
57335         } // getOperandSize
57336
57337         bool
57338         isSrcOperand(int opIdx) override
57339         {
57340             switch (opIdx) {
57341               case 0: //src_0
57342                 return true;
57343               case 1: //src_1
57344                 return true;
57345               case 2: //vdst
57346                 return false;
57347               default:
57348                 fatal("op idx %i out of bounds\n", opIdx);
57349                 return false;
57350             }
57351         } // isSrcOperand
57352
57353         bool
57354         isDstOperand(int opIdx) override
57355         {
57356             switch (opIdx) {
57357               case 0: //src_0
57358                 return false;
57359               case 1: //src_1
57360                 return false;
57361               case 2: //vdst
57362                 return true;
57363               default:
57364                 fatal("op idx %i out of bounds\n", opIdx);
57365                 return false;
57366             }
57367         } // isDstOperand
57368
57369         void execute(GPUDynInstPtr) override;
57370     }; // Inst_VOP3__V_MUL_HI_U32
57371
57372     class Inst_VOP3__V_MUL_HI_I32 : public Inst_VOP3
57373     {
57374       public:
57375         Inst_VOP3__V_MUL_HI_I32(InFmt_VOP3*);
57376         ~Inst_VOP3__V_MUL_HI_I32();
57377
57378         int
57379         getNumOperands() override
57380         {
57381             return numDstRegOperands() + numSrcRegOperands();
57382         } // getNumOperands
57383
57384         int numDstRegOperands() override { return 1; }
57385         int numSrcRegOperands() override { return 2; }
57386
57387         int
57388         getOperandSize(int opIdx) override
57389         {
57390             switch (opIdx) {
57391               case 0: //src_0
57392                 return 4;
57393               case 1: //src_1
57394                 return 4;
57395               case 2: //vdst
57396                 return 4;
57397               default:
57398                 fatal("op idx %i out of bounds\n", opIdx);
57399                 return -1;
57400             }
57401         } // getOperandSize
57402
57403         bool
57404         isSrcOperand(int opIdx) override
57405         {
57406             switch (opIdx) {
57407               case 0: //src_0
57408                 return true;
57409               case 1: //src_1
57410                 return true;
57411               case 2: //vdst
57412                 return false;
57413               default:
57414                 fatal("op idx %i out of bounds\n", opIdx);
57415                 return false;
57416             }
57417         } // isSrcOperand
57418
57419         bool
57420         isDstOperand(int opIdx) override
57421         {
57422             switch (opIdx) {
57423               case 0: //src_0
57424                 return false;
57425               case 1: //src_1
57426                 return false;
57427               case 2: //vdst
57428                 return true;
57429               default:
57430                 fatal("op idx %i out of bounds\n", opIdx);
57431                 return false;
57432             }
57433         } // isDstOperand
57434
57435         void execute(GPUDynInstPtr) override;
57436     }; // Inst_VOP3__V_MUL_HI_I32
57437
57438     class Inst_VOP3__V_LDEXP_F32 : public Inst_VOP3
57439     {
57440       public:
57441         Inst_VOP3__V_LDEXP_F32(InFmt_VOP3*);
57442         ~Inst_VOP3__V_LDEXP_F32();
57443
57444         int
57445         getNumOperands() override
57446         {
57447             return numDstRegOperands() + numSrcRegOperands();
57448         } // getNumOperands
57449
57450         int numDstRegOperands() override { return 1; }
57451         int numSrcRegOperands() override { return 2; }
57452
57453         int
57454         getOperandSize(int opIdx) override
57455         {
57456             switch (opIdx) {
57457               case 0: //src_0
57458                 return 4;
57459               case 1: //src_1
57460                 return 4;
57461               case 2: //vdst
57462                 return 4;
57463               default:
57464                 fatal("op idx %i out of bounds\n", opIdx);
57465                 return -1;
57466             }
57467         } // getOperandSize
57468
57469         bool
57470         isSrcOperand(int opIdx) override
57471         {
57472             switch (opIdx) {
57473               case 0: //src_0
57474                 return true;
57475               case 1: //src_1
57476                 return true;
57477               case 2: //vdst
57478                 return false;
57479               default:
57480                 fatal("op idx %i out of bounds\n", opIdx);
57481                 return false;
57482             }
57483         } // isSrcOperand
57484
57485         bool
57486         isDstOperand(int opIdx) override
57487         {
57488             switch (opIdx) {
57489               case 0: //src_0
57490                 return false;
57491               case 1: //src_1
57492                 return false;
57493               case 2: //vdst
57494                 return true;
57495               default:
57496                 fatal("op idx %i out of bounds\n", opIdx);
57497                 return false;
57498             }
57499         } // isDstOperand
57500
57501         void execute(GPUDynInstPtr) override;
57502     }; // Inst_VOP3__V_LDEXP_F32
57503
57504     class Inst_VOP3__V_READLANE_B32 : public Inst_VOP3
57505     {
57506       public:
57507         Inst_VOP3__V_READLANE_B32(InFmt_VOP3*);
57508         ~Inst_VOP3__V_READLANE_B32();
57509
57510         int
57511         getNumOperands() override
57512         {
57513             return numDstRegOperands() + numSrcRegOperands();
57514         } // getNumOperands
57515
57516         int numDstRegOperands() override { return 1; }
57517         int numSrcRegOperands() override { return 2; }
57518
57519         int
57520         getOperandSize(int opIdx) override
57521         {
57522             switch (opIdx) {
57523               case 0: //vsrc_0
57524                 return 4;
57525               case 1: //ssrc_1
57526                 return 4;
57527               case 2: //sdst
57528                 return 4;
57529               default:
57530                 fatal("op idx %i out of bounds\n", opIdx);
57531                 return -1;
57532             }
57533         } // getOperandSize
57534
57535         bool
57536         isSrcOperand(int opIdx) override
57537         {
57538             switch (opIdx) {
57539               case 0: //vsrc_0
57540                 return true;
57541               case 1: //ssrc_1
57542                 return true;
57543               case 2: //sdst
57544                 return false;
57545               default:
57546                 fatal("op idx %i out of bounds\n", opIdx);
57547                 return false;
57548             }
57549         } // isSrcOperand
57550
57551         bool
57552         isDstOperand(int opIdx) override
57553         {
57554             switch (opIdx) {
57555               case 0: //vsrc_0
57556                 return false;
57557               case 1: //ssrc_1
57558                 return false;
57559               case 2: //sdst
57560                 return true;
57561               default:
57562                 fatal("op idx %i out of bounds\n", opIdx);
57563                 return false;
57564             }
57565         } // isDstOperand
57566
57567         void execute(GPUDynInstPtr) override;
57568     }; // Inst_VOP3__V_READLANE_B32
57569
57570     class Inst_VOP3__V_WRITELANE_B32 : public Inst_VOP3
57571     {
57572       public:
57573         Inst_VOP3__V_WRITELANE_B32(InFmt_VOP3*);
57574         ~Inst_VOP3__V_WRITELANE_B32();
57575
57576         int
57577         getNumOperands() override
57578         {
57579             return numDstRegOperands() + numSrcRegOperands();
57580         } // getNumOperands
57581
57582         int numDstRegOperands() override { return 1; }
57583         int numSrcRegOperands() override { return 2; }
57584
57585         int
57586         getOperandSize(int opIdx) override
57587         {
57588             switch (opIdx) {
57589               case 0: //ssrc_0
57590                 return 4;
57591               case 1: //ssrc_1
57592                 return 4;
57593               case 2: //vdst
57594                 return 4;
57595               default:
57596                 fatal("op idx %i out of bounds\n", opIdx);
57597                 return -1;
57598             }
57599         } // getOperandSize
57600
57601         bool
57602         isSrcOperand(int opIdx) override
57603         {
57604             switch (opIdx) {
57605               case 0: //ssrc_0
57606                 return true;
57607               case 1: //ssrc_1
57608                 return true;
57609               case 2: //vdst
57610                 return false;
57611               default:
57612                 fatal("op idx %i out of bounds\n", opIdx);
57613                 return false;
57614             }
57615         } // isSrcOperand
57616
57617         bool
57618         isDstOperand(int opIdx) override
57619         {
57620             switch (opIdx) {
57621               case 0: //ssrc_0
57622                 return false;
57623               case 1: //ssrc_1
57624                 return false;
57625               case 2: //vdst
57626                 return true;
57627               default:
57628                 fatal("op idx %i out of bounds\n", opIdx);
57629                 return false;
57630             }
57631         } // isDstOperand
57632
57633         void execute(GPUDynInstPtr) override;
57634     }; // Inst_VOP3__V_WRITELANE_B32
57635
57636     class Inst_VOP3__V_BCNT_U32_B32 : public Inst_VOP3
57637     {
57638       public:
57639         Inst_VOP3__V_BCNT_U32_B32(InFmt_VOP3*);
57640         ~Inst_VOP3__V_BCNT_U32_B32();
57641
57642         int
57643         getNumOperands() override
57644         {
57645             return numDstRegOperands() + numSrcRegOperands();
57646         } // getNumOperands
57647
57648         int numDstRegOperands() override { return 1; }
57649         int numSrcRegOperands() override { return 2; }
57650
57651         int
57652         getOperandSize(int opIdx) override
57653         {
57654             switch (opIdx) {
57655               case 0: //src_0
57656                 return 4;
57657               case 1: //src_1
57658                 return 4;
57659               case 2: //vdst
57660                 return 4;
57661               default:
57662                 fatal("op idx %i out of bounds\n", opIdx);
57663                 return -1;
57664             }
57665         } // getOperandSize
57666
57667         bool
57668         isSrcOperand(int opIdx) override
57669         {
57670             switch (opIdx) {
57671               case 0: //src_0
57672                 return true;
57673               case 1: //src_1
57674                 return true;
57675               case 2: //vdst
57676                 return false;
57677               default:
57678                 fatal("op idx %i out of bounds\n", opIdx);
57679                 return false;
57680             }
57681         } // isSrcOperand
57682
57683         bool
57684         isDstOperand(int opIdx) override
57685         {
57686             switch (opIdx) {
57687               case 0: //src_0
57688                 return false;
57689               case 1: //src_1
57690                 return false;
57691               case 2: //vdst
57692                 return true;
57693               default:
57694                 fatal("op idx %i out of bounds\n", opIdx);
57695                 return false;
57696             }
57697         } // isDstOperand
57698
57699         void execute(GPUDynInstPtr) override;
57700     }; // Inst_VOP3__V_BCNT_U32_B32
57701
57702     class Inst_VOP3__V_MBCNT_LO_U32_B32 : public Inst_VOP3
57703     {
57704       public:
57705         Inst_VOP3__V_MBCNT_LO_U32_B32(InFmt_VOP3*);
57706         ~Inst_VOP3__V_MBCNT_LO_U32_B32();
57707
57708         int
57709         getNumOperands() override
57710         {
57711             return numDstRegOperands() + numSrcRegOperands();
57712         } // getNumOperands
57713
57714         int numDstRegOperands() override { return 1; }
57715         int numSrcRegOperands() override { return 2; }
57716
57717         int
57718         getOperandSize(int opIdx) override
57719         {
57720             switch (opIdx) {
57721               case 0: //src_0
57722                 return 4;
57723               case 1: //src_1
57724                 return 4;
57725               case 2: //vdst
57726                 return 4;
57727               default:
57728                 fatal("op idx %i out of bounds\n", opIdx);
57729                 return -1;
57730             }
57731         } // getOperandSize
57732
57733         bool
57734         isSrcOperand(int opIdx) override
57735         {
57736             switch (opIdx) {
57737               case 0: //src_0
57738                 return true;
57739               case 1: //src_1
57740                 return true;
57741               case 2: //vdst
57742                 return false;
57743               default:
57744                 fatal("op idx %i out of bounds\n", opIdx);
57745                 return false;
57746             }
57747         } // isSrcOperand
57748
57749         bool
57750         isDstOperand(int opIdx) override
57751         {
57752             switch (opIdx) {
57753               case 0: //src_0
57754                 return false;
57755               case 1: //src_1
57756                 return false;
57757               case 2: //vdst
57758                 return true;
57759               default:
57760                 fatal("op idx %i out of bounds\n", opIdx);
57761                 return false;
57762             }
57763         } // isDstOperand
57764
57765         void execute(GPUDynInstPtr) override;
57766     }; // Inst_VOP3__V_MBCNT_LO_U32_B32
57767
57768     class Inst_VOP3__V_MBCNT_HI_U32_B32 : public Inst_VOP3
57769     {
57770       public:
57771         Inst_VOP3__V_MBCNT_HI_U32_B32(InFmt_VOP3*);
57772         ~Inst_VOP3__V_MBCNT_HI_U32_B32();
57773
57774         int
57775         getNumOperands() override
57776         {
57777             return numDstRegOperands() + numSrcRegOperands();
57778         } // getNumOperands
57779
57780         int numDstRegOperands() override { return 1; }
57781         int numSrcRegOperands() override { return 2; }
57782
57783         int
57784         getOperandSize(int opIdx) override
57785         {
57786             switch (opIdx) {
57787               case 0: //src_0
57788                 return 4;
57789               case 1: //src_1
57790                 return 4;
57791               case 2: //vdst
57792                 return 4;
57793               default:
57794                 fatal("op idx %i out of bounds\n", opIdx);
57795                 return -1;
57796             }
57797         } // getOperandSize
57798
57799         bool
57800         isSrcOperand(int opIdx) override
57801         {
57802             switch (opIdx) {
57803               case 0: //src_0
57804                 return true;
57805               case 1: //src_1
57806                 return true;
57807               case 2: //vdst
57808                 return false;
57809               default:
57810                 fatal("op idx %i out of bounds\n", opIdx);
57811                 return false;
57812             }
57813         } // isSrcOperand
57814
57815         bool
57816         isDstOperand(int opIdx) override
57817         {
57818             switch (opIdx) {
57819               case 0: //src_0
57820                 return false;
57821               case 1: //src_1
57822                 return false;
57823               case 2: //vdst
57824                 return true;
57825               default:
57826                 fatal("op idx %i out of bounds\n", opIdx);
57827                 return false;
57828             }
57829         } // isDstOperand
57830
57831         void execute(GPUDynInstPtr) override;
57832     }; // Inst_VOP3__V_MBCNT_HI_U32_B32
57833
57834     class Inst_VOP3__V_LSHLREV_B64 : public Inst_VOP3
57835     {
57836       public:
57837         Inst_VOP3__V_LSHLREV_B64(InFmt_VOP3*);
57838         ~Inst_VOP3__V_LSHLREV_B64();
57839
57840         int
57841         getNumOperands() override
57842         {
57843             return numDstRegOperands() + numSrcRegOperands();
57844         } // getNumOperands
57845
57846         int numDstRegOperands() override { return 1; }
57847         int numSrcRegOperands() override { return 2; }
57848
57849         int
57850         getOperandSize(int opIdx) override
57851         {
57852             switch (opIdx) {
57853               case 0: //src_0
57854                 return 4;
57855               case 1: //src_1
57856                 return 8;
57857               case 2: //vdst
57858                 return 8;
57859               default:
57860                 fatal("op idx %i out of bounds\n", opIdx);
57861                 return -1;
57862             }
57863         } // getOperandSize
57864
57865         bool
57866         isSrcOperand(int opIdx) override
57867         {
57868             switch (opIdx) {
57869               case 0: //src_0
57870                 return true;
57871               case 1: //src_1
57872                 return true;
57873               case 2: //vdst
57874                 return false;
57875               default:
57876                 fatal("op idx %i out of bounds\n", opIdx);
57877                 return false;
57878             }
57879         } // isSrcOperand
57880
57881         bool
57882         isDstOperand(int opIdx) override
57883         {
57884             switch (opIdx) {
57885               case 0: //src_0
57886                 return false;
57887               case 1: //src_1
57888                 return false;
57889               case 2: //vdst
57890                 return true;
57891               default:
57892                 fatal("op idx %i out of bounds\n", opIdx);
57893                 return false;
57894             }
57895         } // isDstOperand
57896
57897         void execute(GPUDynInstPtr) override;
57898     }; // Inst_VOP3__V_LSHLREV_B64
57899
57900     class Inst_VOP3__V_LSHRREV_B64 : public Inst_VOP3
57901     {
57902       public:
57903         Inst_VOP3__V_LSHRREV_B64(InFmt_VOP3*);
57904         ~Inst_VOP3__V_LSHRREV_B64();
57905
57906         int
57907         getNumOperands() override
57908         {
57909             return numDstRegOperands() + numSrcRegOperands();
57910         } // getNumOperands
57911
57912         int numDstRegOperands() override { return 1; }
57913         int numSrcRegOperands() override { return 2; }
57914
57915         int
57916         getOperandSize(int opIdx) override
57917         {
57918             switch (opIdx) {
57919               case 0: //src_0
57920                 return 4;
57921               case 1: //src_1
57922                 return 8;
57923               case 2: //vdst
57924                 return 8;
57925               default:
57926                 fatal("op idx %i out of bounds\n", opIdx);
57927                 return -1;
57928             }
57929         } // getOperandSize
57930
57931         bool
57932         isSrcOperand(int opIdx) override
57933         {
57934             switch (opIdx) {
57935               case 0: //src_0
57936                 return true;
57937               case 1: //src_1
57938                 return true;
57939               case 2: //vdst
57940                 return false;
57941               default:
57942                 fatal("op idx %i out of bounds\n", opIdx);
57943                 return false;
57944             }
57945         } // isSrcOperand
57946
57947         bool
57948         isDstOperand(int opIdx) override
57949         {
57950             switch (opIdx) {
57951               case 0: //src_0
57952                 return false;
57953               case 1: //src_1
57954                 return false;
57955               case 2: //vdst
57956                 return true;
57957               default:
57958                 fatal("op idx %i out of bounds\n", opIdx);
57959                 return false;
57960             }
57961         } // isDstOperand
57962
57963         void execute(GPUDynInstPtr) override;
57964     }; // Inst_VOP3__V_LSHRREV_B64
57965
57966     class Inst_VOP3__V_ASHRREV_I64 : public Inst_VOP3
57967     {
57968       public:
57969         Inst_VOP3__V_ASHRREV_I64(InFmt_VOP3*);
57970         ~Inst_VOP3__V_ASHRREV_I64();
57971
57972         int
57973         getNumOperands() override
57974         {
57975             return numDstRegOperands() + numSrcRegOperands();
57976         } // getNumOperands
57977
57978         int numDstRegOperands() override { return 1; }
57979         int numSrcRegOperands() override { return 2; }
57980
57981         int
57982         getOperandSize(int opIdx) override
57983         {
57984             switch (opIdx) {
57985               case 0: //src_0
57986                 return 4;
57987               case 1: //src_1
57988                 return 8;
57989               case 2: //vdst
57990                 return 8;
57991               default:
57992                 fatal("op idx %i out of bounds\n", opIdx);
57993                 return -1;
57994             }
57995         } // getOperandSize
57996
57997         bool
57998         isSrcOperand(int opIdx) override
57999         {
58000             switch (opIdx) {
58001               case 0: //src_0
58002                 return true;
58003               case 1: //src_1
58004                 return true;
58005               case 2: //vdst
58006                 return false;
58007               default:
58008                 fatal("op idx %i out of bounds\n", opIdx);
58009                 return false;
58010             }
58011         } // isSrcOperand
58012
58013         bool
58014         isDstOperand(int opIdx) override
58015         {
58016             switch (opIdx) {
58017               case 0: //src_0
58018                 return false;
58019               case 1: //src_1
58020                 return false;
58021               case 2: //vdst
58022                 return true;
58023               default:
58024                 fatal("op idx %i out of bounds\n", opIdx);
58025                 return false;
58026             }
58027         } // isDstOperand
58028
58029         void execute(GPUDynInstPtr) override;
58030     }; // Inst_VOP3__V_ASHRREV_I64
58031
58032     class Inst_VOP3__V_TRIG_PREOP_F64 : public Inst_VOP3
58033     {
58034       public:
58035         Inst_VOP3__V_TRIG_PREOP_F64(InFmt_VOP3*);
58036         ~Inst_VOP3__V_TRIG_PREOP_F64();
58037
58038         int
58039         getNumOperands() override
58040         {
58041             return numDstRegOperands() + numSrcRegOperands();
58042         } // getNumOperands
58043
58044         int numDstRegOperands() override { return 1; }
58045         int numSrcRegOperands() override { return 2; }
58046
58047         int
58048         getOperandSize(int opIdx) override
58049         {
58050             switch (opIdx) {
58051               case 0: //src_0
58052                 return 8;
58053               case 1: //src_1
58054                 return 4;
58055               case 2: //vdst
58056                 return 8;
58057               default:
58058                 fatal("op idx %i out of bounds\n", opIdx);
58059                 return -1;
58060             }
58061         } // getOperandSize
58062
58063         bool
58064         isSrcOperand(int opIdx) override
58065         {
58066             switch (opIdx) {
58067               case 0: //src_0
58068                 return true;
58069               case 1: //src_1
58070                 return true;
58071               case 2: //vdst
58072                 return false;
58073               default:
58074                 fatal("op idx %i out of bounds\n", opIdx);
58075                 return false;
58076             }
58077         } // isSrcOperand
58078
58079         bool
58080         isDstOperand(int opIdx) override
58081         {
58082             switch (opIdx) {
58083               case 0: //src_0
58084                 return false;
58085               case 1: //src_1
58086                 return false;
58087               case 2: //vdst
58088                 return true;
58089               default:
58090                 fatal("op idx %i out of bounds\n", opIdx);
58091                 return false;
58092             }
58093         } // isDstOperand
58094
58095         void execute(GPUDynInstPtr) override;
58096     }; // Inst_VOP3__V_TRIG_PREOP_F64
58097
58098     class Inst_VOP3__V_BFM_B32 : public Inst_VOP3
58099     {
58100       public:
58101         Inst_VOP3__V_BFM_B32(InFmt_VOP3*);
58102         ~Inst_VOP3__V_BFM_B32();
58103
58104         int
58105         getNumOperands() override
58106         {
58107             return numDstRegOperands() + numSrcRegOperands();
58108         } // getNumOperands
58109
58110         int numDstRegOperands() override { return 1; }
58111         int numSrcRegOperands() override { return 2; }
58112
58113         int
58114         getOperandSize(int opIdx) override
58115         {
58116             switch (opIdx) {
58117               case 0: //src_0
58118                 return 4;
58119               case 1: //src_1
58120                 return 4;
58121               case 2: //vdst
58122                 return 4;
58123               default:
58124                 fatal("op idx %i out of bounds\n", opIdx);
58125                 return -1;
58126             }
58127         } // getOperandSize
58128
58129         bool
58130         isSrcOperand(int opIdx) override
58131         {
58132             switch (opIdx) {
58133               case 0: //src_0
58134                 return true;
58135               case 1: //src_1
58136                 return true;
58137               case 2: //vdst
58138                 return false;
58139               default:
58140                 fatal("op idx %i out of bounds\n", opIdx);
58141                 return false;
58142             }
58143         } // isSrcOperand
58144
58145         bool
58146         isDstOperand(int opIdx) override
58147         {
58148             switch (opIdx) {
58149               case 0: //src_0
58150                 return false;
58151               case 1: //src_1
58152                 return false;
58153               case 2: //vdst
58154                 return true;
58155               default:
58156                 fatal("op idx %i out of bounds\n", opIdx);
58157                 return false;
58158             }
58159         } // isDstOperand
58160
58161         void execute(GPUDynInstPtr) override;
58162     }; // Inst_VOP3__V_BFM_B32
58163
58164     class Inst_VOP3__V_CVT_PKNORM_I16_F32 : public Inst_VOP3
58165     {
58166       public:
58167         Inst_VOP3__V_CVT_PKNORM_I16_F32(InFmt_VOP3*);
58168         ~Inst_VOP3__V_CVT_PKNORM_I16_F32();
58169
58170         int
58171         getNumOperands() override
58172         {
58173             return numDstRegOperands() + numSrcRegOperands();
58174         } // getNumOperands
58175
58176         int numDstRegOperands() override { return 1; }
58177         int numSrcRegOperands() override { return 2; }
58178
58179         int
58180         getOperandSize(int opIdx) override
58181         {
58182             switch (opIdx) {
58183               case 0: //src_0
58184                 return 4;
58185               case 1: //src_1
58186                 return 4;
58187               case 2: //vdst
58188                 return 2;
58189               default:
58190                 fatal("op idx %i out of bounds\n", opIdx);
58191                 return -1;
58192             }
58193         } // getOperandSize
58194
58195         bool
58196         isSrcOperand(int opIdx) override
58197         {
58198             switch (opIdx) {
58199               case 0: //src_0
58200                 return true;
58201               case 1: //src_1
58202                 return true;
58203               case 2: //vdst
58204                 return false;
58205               default:
58206                 fatal("op idx %i out of bounds\n", opIdx);
58207                 return false;
58208             }
58209         } // isSrcOperand
58210
58211         bool
58212         isDstOperand(int opIdx) override
58213         {
58214             switch (opIdx) {
58215               case 0: //src_0
58216                 return false;
58217               case 1: //src_1
58218                 return false;
58219               case 2: //vdst
58220                 return true;
58221               default:
58222                 fatal("op idx %i out of bounds\n", opIdx);
58223                 return false;
58224             }
58225         } // isDstOperand
58226
58227         void execute(GPUDynInstPtr) override;
58228     }; // Inst_VOP3__V_CVT_PKNORM_I16_F32
58229
58230     class Inst_VOP3__V_CVT_PKNORM_U16_F32 : public Inst_VOP3
58231     {
58232       public:
58233         Inst_VOP3__V_CVT_PKNORM_U16_F32(InFmt_VOP3*);
58234         ~Inst_VOP3__V_CVT_PKNORM_U16_F32();
58235
58236         int
58237         getNumOperands() override
58238         {
58239             return numDstRegOperands() + numSrcRegOperands();
58240         } // getNumOperands
58241
58242         int numDstRegOperands() override { return 1; }
58243         int numSrcRegOperands() override { return 2; }
58244
58245         int
58246         getOperandSize(int opIdx) override
58247         {
58248             switch (opIdx) {
58249               case 0: //src_0
58250                 return 4;
58251               case 1: //src_1
58252                 return 4;
58253               case 2: //vdst
58254                 return 2;
58255               default:
58256                 fatal("op idx %i out of bounds\n", opIdx);
58257                 return -1;
58258             }
58259         } // getOperandSize
58260
58261         bool
58262         isSrcOperand(int opIdx) override
58263         {
58264             switch (opIdx) {
58265               case 0: //src_0
58266                 return true;
58267               case 1: //src_1
58268                 return true;
58269               case 2: //vdst
58270                 return false;
58271               default:
58272                 fatal("op idx %i out of bounds\n", opIdx);
58273                 return false;
58274             }
58275         } // isSrcOperand
58276
58277         bool
58278         isDstOperand(int opIdx) override
58279         {
58280             switch (opIdx) {
58281               case 0: //src_0
58282                 return false;
58283               case 1: //src_1
58284                 return false;
58285               case 2: //vdst
58286                 return true;
58287               default:
58288                 fatal("op idx %i out of bounds\n", opIdx);
58289                 return false;
58290             }
58291         } // isDstOperand
58292
58293         void execute(GPUDynInstPtr) override;
58294     }; // Inst_VOP3__V_CVT_PKNORM_U16_F32
58295
58296     class Inst_VOP3__V_CVT_PKRTZ_F16_F32 : public Inst_VOP3
58297     {
58298       public:
58299         Inst_VOP3__V_CVT_PKRTZ_F16_F32(InFmt_VOP3*);
58300         ~Inst_VOP3__V_CVT_PKRTZ_F16_F32();
58301
58302         int
58303         getNumOperands() override
58304         {
58305             return numDstRegOperands() + numSrcRegOperands();
58306         } // getNumOperands
58307
58308         int numDstRegOperands() override { return 1; }
58309         int numSrcRegOperands() override { return 2; }
58310
58311         int
58312         getOperandSize(int opIdx) override
58313         {
58314             switch (opIdx) {
58315               case 0: //src_0
58316                 return 4;
58317               case 1: //src_1
58318                 return 4;
58319               case 2: //vdst
58320                 return 4;
58321               default:
58322                 fatal("op idx %i out of bounds\n", opIdx);
58323                 return -1;
58324             }
58325         } // getOperandSize
58326
58327         bool
58328         isSrcOperand(int opIdx) override
58329         {
58330             switch (opIdx) {
58331               case 0: //src_0
58332                 return true;
58333               case 1: //src_1
58334                 return true;
58335               case 2: //vdst
58336                 return false;
58337               default:
58338                 fatal("op idx %i out of bounds\n", opIdx);
58339                 return false;
58340             }
58341         } // isSrcOperand
58342
58343         bool
58344         isDstOperand(int opIdx) override
58345         {
58346             switch (opIdx) {
58347               case 0: //src_0
58348                 return false;
58349               case 1: //src_1
58350                 return false;
58351               case 2: //vdst
58352                 return true;
58353               default:
58354                 fatal("op idx %i out of bounds\n", opIdx);
58355                 return false;
58356             }
58357         } // isDstOperand
58358
58359         void execute(GPUDynInstPtr) override;
58360     }; // Inst_VOP3__V_CVT_PKRTZ_F16_F32
58361
58362     class Inst_VOP3__V_CVT_PK_U16_U32 : public Inst_VOP3
58363     {
58364       public:
58365         Inst_VOP3__V_CVT_PK_U16_U32(InFmt_VOP3*);
58366         ~Inst_VOP3__V_CVT_PK_U16_U32();
58367
58368         int
58369         getNumOperands() override
58370         {
58371             return numDstRegOperands() + numSrcRegOperands();
58372         } // getNumOperands
58373
58374         int numDstRegOperands() override { return 1; }
58375         int numSrcRegOperands() override { return 2; }
58376
58377         int
58378         getOperandSize(int opIdx) override
58379         {
58380             switch (opIdx) {
58381               case 0: //src_0
58382                 return 4;
58383               case 1: //src_1
58384                 return 4;
58385               case 2: //vdst
58386                 return 4;
58387               default:
58388                 fatal("op idx %i out of bounds\n", opIdx);
58389                 return -1;
58390             }
58391         } // getOperandSize
58392
58393         bool
58394         isSrcOperand(int opIdx) override
58395         {
58396             switch (opIdx) {
58397               case 0: //src_0
58398                 return true;
58399               case 1: //src_1
58400                 return true;
58401               case 2: //vdst
58402                 return false;
58403               default:
58404                 fatal("op idx %i out of bounds\n", opIdx);
58405                 return false;
58406             }
58407         } // isSrcOperand
58408
58409         bool
58410         isDstOperand(int opIdx) override
58411         {
58412             switch (opIdx) {
58413               case 0: //src_0
58414                 return false;
58415               case 1: //src_1
58416                 return false;
58417               case 2: //vdst
58418                 return true;
58419               default:
58420                 fatal("op idx %i out of bounds\n", opIdx);
58421                 return false;
58422             }
58423         } // isDstOperand
58424
58425         void execute(GPUDynInstPtr) override;
58426     }; // Inst_VOP3__V_CVT_PK_U16_U32
58427
58428     class Inst_VOP3__V_CVT_PK_I16_I32 : public Inst_VOP3
58429     {
58430       public:
58431         Inst_VOP3__V_CVT_PK_I16_I32(InFmt_VOP3*);
58432         ~Inst_VOP3__V_CVT_PK_I16_I32();
58433
58434         int
58435         getNumOperands() override
58436         {
58437             return numDstRegOperands() + numSrcRegOperands();
58438         } // getNumOperands
58439
58440         int numDstRegOperands() override { return 1; }
58441         int numSrcRegOperands() override { return 2; }
58442
58443         int
58444         getOperandSize(int opIdx) override
58445         {
58446             switch (opIdx) {
58447               case 0: //src_0
58448                 return 4;
58449               case 1: //src_1
58450                 return 4;
58451               case 2: //vdst
58452                 return 4;
58453               default:
58454                 fatal("op idx %i out of bounds\n", opIdx);
58455                 return -1;
58456             }
58457         } // getOperandSize
58458
58459         bool
58460         isSrcOperand(int opIdx) override
58461         {
58462             switch (opIdx) {
58463               case 0: //src_0
58464                 return true;
58465               case 1: //src_1
58466                 return true;
58467               case 2: //vdst
58468                 return false;
58469               default:
58470                 fatal("op idx %i out of bounds\n", opIdx);
58471                 return false;
58472             }
58473         } // isSrcOperand
58474
58475         bool
58476         isDstOperand(int opIdx) override
58477         {
58478             switch (opIdx) {
58479               case 0: //src_0
58480                 return false;
58481               case 1: //src_1
58482                 return false;
58483               case 2: //vdst
58484                 return true;
58485               default:
58486                 fatal("op idx %i out of bounds\n", opIdx);
58487                 return false;
58488             }
58489         } // isDstOperand
58490
58491         void execute(GPUDynInstPtr) override;
58492     }; // Inst_VOP3__V_CVT_PK_I16_I32
58493
58494     class Inst_DS__DS_ADD_U32 : public Inst_DS
58495     {
58496       public:
58497         Inst_DS__DS_ADD_U32(InFmt_DS*);
58498         ~Inst_DS__DS_ADD_U32();
58499
58500         int
58501         getNumOperands() override
58502         {
58503             return numDstRegOperands() + numSrcRegOperands();
58504         } // getNumOperands
58505
58506         int numDstRegOperands() override { return 0; }
58507         int numSrcRegOperands() override { return 2; }
58508
58509         int
58510         getOperandSize(int opIdx) override
58511         {
58512             switch (opIdx) {
58513               case 0: //vgpr_a
58514                 return 4;
58515               case 1: //vgpr_d0
58516                 return 4;
58517               default:
58518                 fatal("op idx %i out of bounds\n", opIdx);
58519                 return -1;
58520             }
58521         } // getOperandSize
58522
58523         bool
58524         isSrcOperand(int opIdx) override
58525         {
58526             switch (opIdx) {
58527               case 0: //vgpr_a
58528                 return true;
58529               case 1: //vgpr_d0
58530                 return true;
58531               default:
58532                 fatal("op idx %i out of bounds\n", opIdx);
58533                 return false;
58534             }
58535         } // isSrcOperand
58536
58537         bool
58538         isDstOperand(int opIdx) override
58539         {
58540             switch (opIdx) {
58541               case 0: //vgpr_a
58542                 return false;
58543               case 1: //vgpr_d0
58544                 return false;
58545               default:
58546                 fatal("op idx %i out of bounds\n", opIdx);
58547                 return false;
58548             }
58549         } // isDstOperand
58550
58551         void execute(GPUDynInstPtr) override;
58552     }; // Inst_DS__DS_ADD_U32
58553
58554     class Inst_DS__DS_SUB_U32 : public Inst_DS
58555     {
58556       public:
58557         Inst_DS__DS_SUB_U32(InFmt_DS*);
58558         ~Inst_DS__DS_SUB_U32();
58559
58560         int
58561         getNumOperands() override
58562         {
58563             return numDstRegOperands() + numSrcRegOperands();
58564         } // getNumOperands
58565
58566         int numDstRegOperands() override { return 0; }
58567         int numSrcRegOperands() override { return 2; }
58568
58569         int
58570         getOperandSize(int opIdx) override
58571         {
58572             switch (opIdx) {
58573               case 0: //vgpr_a
58574                 return 4;
58575               case 1: //vgpr_d0
58576                 return 4;
58577               default:
58578                 fatal("op idx %i out of bounds\n", opIdx);
58579                 return -1;
58580             }
58581         } // getOperandSize
58582
58583         bool
58584         isSrcOperand(int opIdx) override
58585         {
58586             switch (opIdx) {
58587               case 0: //vgpr_a
58588                 return true;
58589               case 1: //vgpr_d0
58590                 return true;
58591               default:
58592                 fatal("op idx %i out of bounds\n", opIdx);
58593                 return false;
58594             }
58595         } // isSrcOperand
58596
58597         bool
58598         isDstOperand(int opIdx) override
58599         {
58600             switch (opIdx) {
58601               case 0: //vgpr_a
58602                 return false;
58603               case 1: //vgpr_d0
58604                 return false;
58605               default:
58606                 fatal("op idx %i out of bounds\n", opIdx);
58607                 return false;
58608             }
58609         } // isDstOperand
58610
58611         void execute(GPUDynInstPtr) override;
58612     }; // Inst_DS__DS_SUB_U32
58613
58614     class Inst_DS__DS_RSUB_U32 : public Inst_DS
58615     {
58616       public:
58617         Inst_DS__DS_RSUB_U32(InFmt_DS*);
58618         ~Inst_DS__DS_RSUB_U32();
58619
58620         int
58621         getNumOperands() override
58622         {
58623             return numDstRegOperands() + numSrcRegOperands();
58624         } // getNumOperands
58625
58626         int numDstRegOperands() override { return 0; }
58627         int numSrcRegOperands() override { return 2; }
58628
58629         int
58630         getOperandSize(int opIdx) override
58631         {
58632             switch (opIdx) {
58633               case 0: //vgpr_a
58634                 return 4;
58635               case 1: //vgpr_d0
58636                 return 4;
58637               default:
58638                 fatal("op idx %i out of bounds\n", opIdx);
58639                 return -1;
58640             }
58641         } // getOperandSize
58642
58643         bool
58644         isSrcOperand(int opIdx) override
58645         {
58646             switch (opIdx) {
58647               case 0: //vgpr_a
58648                 return true;
58649               case 1: //vgpr_d0
58650                 return true;
58651               default:
58652                 fatal("op idx %i out of bounds\n", opIdx);
58653                 return false;
58654             }
58655         } // isSrcOperand
58656
58657         bool
58658         isDstOperand(int opIdx) override
58659         {
58660             switch (opIdx) {
58661               case 0: //vgpr_a
58662                 return false;
58663               case 1: //vgpr_d0
58664                 return false;
58665               default:
58666                 fatal("op idx %i out of bounds\n", opIdx);
58667                 return false;
58668             }
58669         } // isDstOperand
58670
58671         void execute(GPUDynInstPtr) override;
58672     }; // Inst_DS__DS_RSUB_U32
58673
58674     class Inst_DS__DS_INC_U32 : public Inst_DS
58675     {
58676       public:
58677         Inst_DS__DS_INC_U32(InFmt_DS*);
58678         ~Inst_DS__DS_INC_U32();
58679
58680         int
58681         getNumOperands() override
58682         {
58683             return numDstRegOperands() + numSrcRegOperands();
58684         } // getNumOperands
58685
58686         int numDstRegOperands() override { return 0; }
58687         int numSrcRegOperands() override { return 2; }
58688
58689         int
58690         getOperandSize(int opIdx) override
58691         {
58692             switch (opIdx) {
58693               case 0: //vgpr_a
58694                 return 4;
58695               case 1: //vgpr_d0
58696                 return 4;
58697               default:
58698                 fatal("op idx %i out of bounds\n", opIdx);
58699                 return -1;
58700             }
58701         } // getOperandSize
58702
58703         bool
58704         isSrcOperand(int opIdx) override
58705         {
58706             switch (opIdx) {
58707               case 0: //vgpr_a
58708                 return true;
58709               case 1: //vgpr_d0
58710                 return true;
58711               default:
58712                 fatal("op idx %i out of bounds\n", opIdx);
58713                 return false;
58714             }
58715         } // isSrcOperand
58716
58717         bool
58718         isDstOperand(int opIdx) override
58719         {
58720             switch (opIdx) {
58721               case 0: //vgpr_a
58722                 return false;
58723               case 1: //vgpr_d0
58724                 return false;
58725               default:
58726                 fatal("op idx %i out of bounds\n", opIdx);
58727                 return false;
58728             }
58729         } // isDstOperand
58730
58731         void execute(GPUDynInstPtr) override;
58732     }; // Inst_DS__DS_INC_U32
58733
58734     class Inst_DS__DS_DEC_U32 : public Inst_DS
58735     {
58736       public:
58737         Inst_DS__DS_DEC_U32(InFmt_DS*);
58738         ~Inst_DS__DS_DEC_U32();
58739
58740         int
58741         getNumOperands() override
58742         {
58743             return numDstRegOperands() + numSrcRegOperands();
58744         } // getNumOperands
58745
58746         int numDstRegOperands() override { return 0; }
58747         int numSrcRegOperands() override { return 2; }
58748
58749         int
58750         getOperandSize(int opIdx) override
58751         {
58752             switch (opIdx) {
58753               case 0: //vgpr_a
58754                 return 4;
58755               case 1: //vgpr_d0
58756                 return 4;
58757               default:
58758                 fatal("op idx %i out of bounds\n", opIdx);
58759                 return -1;
58760             }
58761         } // getOperandSize
58762
58763         bool
58764         isSrcOperand(int opIdx) override
58765         {
58766             switch (opIdx) {
58767               case 0: //vgpr_a
58768                 return true;
58769               case 1: //vgpr_d0
58770                 return true;
58771               default:
58772                 fatal("op idx %i out of bounds\n", opIdx);
58773                 return false;
58774             }
58775         } // isSrcOperand
58776
58777         bool
58778         isDstOperand(int opIdx) override
58779         {
58780             switch (opIdx) {
58781               case 0: //vgpr_a
58782                 return false;
58783               case 1: //vgpr_d0
58784                 return false;
58785               default:
58786                 fatal("op idx %i out of bounds\n", opIdx);
58787                 return false;
58788             }
58789         } // isDstOperand
58790
58791         void execute(GPUDynInstPtr) override;
58792     }; // Inst_DS__DS_DEC_U32
58793
58794     class Inst_DS__DS_MIN_I32 : public Inst_DS
58795     {
58796       public:
58797         Inst_DS__DS_MIN_I32(InFmt_DS*);
58798         ~Inst_DS__DS_MIN_I32();
58799
58800         int
58801         getNumOperands() override
58802         {
58803             return numDstRegOperands() + numSrcRegOperands();
58804         } // getNumOperands
58805
58806         int numDstRegOperands() override { return 0; }
58807         int numSrcRegOperands() override { return 2; }
58808
58809         int
58810         getOperandSize(int opIdx) override
58811         {
58812             switch (opIdx) {
58813               case 0: //vgpr_a
58814                 return 4;
58815               case 1: //vgpr_d0
58816                 return 4;
58817               default:
58818                 fatal("op idx %i out of bounds\n", opIdx);
58819                 return -1;
58820             }
58821         } // getOperandSize
58822
58823         bool
58824         isSrcOperand(int opIdx) override
58825         {
58826             switch (opIdx) {
58827               case 0: //vgpr_a
58828                 return true;
58829               case 1: //vgpr_d0
58830                 return true;
58831               default:
58832                 fatal("op idx %i out of bounds\n", opIdx);
58833                 return false;
58834             }
58835         } // isSrcOperand
58836
58837         bool
58838         isDstOperand(int opIdx) override
58839         {
58840             switch (opIdx) {
58841               case 0: //vgpr_a
58842                 return false;
58843               case 1: //vgpr_d0
58844                 return false;
58845               default:
58846                 fatal("op idx %i out of bounds\n", opIdx);
58847                 return false;
58848             }
58849         } // isDstOperand
58850
58851         void execute(GPUDynInstPtr) override;
58852     }; // Inst_DS__DS_MIN_I32
58853
58854     class Inst_DS__DS_MAX_I32 : public Inst_DS
58855     {
58856       public:
58857         Inst_DS__DS_MAX_I32(InFmt_DS*);
58858         ~Inst_DS__DS_MAX_I32();
58859
58860         int
58861         getNumOperands() override
58862         {
58863             return numDstRegOperands() + numSrcRegOperands();
58864         } // getNumOperands
58865
58866         int numDstRegOperands() override { return 0; }
58867         int numSrcRegOperands() override { return 2; }
58868
58869         int
58870         getOperandSize(int opIdx) override
58871         {
58872             switch (opIdx) {
58873               case 0: //vgpr_a
58874                 return 4;
58875               case 1: //vgpr_d0
58876                 return 4;
58877               default:
58878                 fatal("op idx %i out of bounds\n", opIdx);
58879                 return -1;
58880             }
58881         } // getOperandSize
58882
58883         bool
58884         isSrcOperand(int opIdx) override
58885         {
58886             switch (opIdx) {
58887               case 0: //vgpr_a
58888                 return true;
58889               case 1: //vgpr_d0
58890                 return true;
58891               default:
58892                 fatal("op idx %i out of bounds\n", opIdx);
58893                 return false;
58894             }
58895         } // isSrcOperand
58896
58897         bool
58898         isDstOperand(int opIdx) override
58899         {
58900             switch (opIdx) {
58901               case 0: //vgpr_a
58902                 return false;
58903               case 1: //vgpr_d0
58904                 return false;
58905               default:
58906                 fatal("op idx %i out of bounds\n", opIdx);
58907                 return false;
58908             }
58909         } // isDstOperand
58910
58911         void execute(GPUDynInstPtr) override;
58912     }; // Inst_DS__DS_MAX_I32
58913
58914     class Inst_DS__DS_MIN_U32 : public Inst_DS
58915     {
58916       public:
58917         Inst_DS__DS_MIN_U32(InFmt_DS*);
58918         ~Inst_DS__DS_MIN_U32();
58919
58920         int
58921         getNumOperands() override
58922         {
58923             return numDstRegOperands() + numSrcRegOperands();
58924         } // getNumOperands
58925
58926         int numDstRegOperands() override { return 0; }
58927         int numSrcRegOperands() override { return 2; }
58928
58929         int
58930         getOperandSize(int opIdx) override
58931         {
58932             switch (opIdx) {
58933               case 0: //vgpr_a
58934                 return 4;
58935               case 1: //vgpr_d0
58936                 return 4;
58937               default:
58938                 fatal("op idx %i out of bounds\n", opIdx);
58939                 return -1;
58940             }
58941         } // getOperandSize
58942
58943         bool
58944         isSrcOperand(int opIdx) override
58945         {
58946             switch (opIdx) {
58947               case 0: //vgpr_a
58948                 return true;
58949               case 1: //vgpr_d0
58950                 return true;
58951               default:
58952                 fatal("op idx %i out of bounds\n", opIdx);
58953                 return false;
58954             }
58955         } // isSrcOperand
58956
58957         bool
58958         isDstOperand(int opIdx) override
58959         {
58960             switch (opIdx) {
58961               case 0: //vgpr_a
58962                 return false;
58963               case 1: //vgpr_d0
58964                 return false;
58965               default:
58966                 fatal("op idx %i out of bounds\n", opIdx);
58967                 return false;
58968             }
58969         } // isDstOperand
58970
58971         void execute(GPUDynInstPtr) override;
58972     }; // Inst_DS__DS_MIN_U32
58973
58974     class Inst_DS__DS_MAX_U32 : public Inst_DS
58975     {
58976       public:
58977         Inst_DS__DS_MAX_U32(InFmt_DS*);
58978         ~Inst_DS__DS_MAX_U32();
58979
58980         int
58981         getNumOperands() override
58982         {
58983             return numDstRegOperands() + numSrcRegOperands();
58984         } // getNumOperands
58985
58986         int numDstRegOperands() override { return 0; }
58987         int numSrcRegOperands() override { return 2; }
58988
58989         int
58990         getOperandSize(int opIdx) override
58991         {
58992             switch (opIdx) {
58993               case 0: //vgpr_a
58994                 return 4;
58995               case 1: //vgpr_d0
58996                 return 4;
58997               default:
58998                 fatal("op idx %i out of bounds\n", opIdx);
58999                 return -1;
59000             }
59001         } // getOperandSize
59002
59003         bool
59004         isSrcOperand(int opIdx) override
59005         {
59006             switch (opIdx) {
59007               case 0: //vgpr_a
59008                 return true;
59009               case 1: //vgpr_d0
59010                 return true;
59011               default:
59012                 fatal("op idx %i out of bounds\n", opIdx);
59013                 return false;
59014             }
59015         } // isSrcOperand
59016
59017         bool
59018         isDstOperand(int opIdx) override
59019         {
59020             switch (opIdx) {
59021               case 0: //vgpr_a
59022                 return false;
59023               case 1: //vgpr_d0
59024                 return false;
59025               default:
59026                 fatal("op idx %i out of bounds\n", opIdx);
59027                 return false;
59028             }
59029         } // isDstOperand
59030
59031         void execute(GPUDynInstPtr) override;
59032     }; // Inst_DS__DS_MAX_U32
59033
59034     class Inst_DS__DS_AND_B32 : public Inst_DS
59035     {
59036       public:
59037         Inst_DS__DS_AND_B32(InFmt_DS*);
59038         ~Inst_DS__DS_AND_B32();
59039
59040         int
59041         getNumOperands() override
59042         {
59043             return numDstRegOperands() + numSrcRegOperands();
59044         } // getNumOperands
59045
59046         int numDstRegOperands() override { return 0; }
59047         int numSrcRegOperands() override { return 2; }
59048
59049         int
59050         getOperandSize(int opIdx) override
59051         {
59052             switch (opIdx) {
59053               case 0: //vgpr_a
59054                 return 4;
59055               case 1: //vgpr_d0
59056                 return 4;
59057               default:
59058                 fatal("op idx %i out of bounds\n", opIdx);
59059                 return -1;
59060             }
59061         } // getOperandSize
59062
59063         bool
59064         isSrcOperand(int opIdx) override
59065         {
59066             switch (opIdx) {
59067               case 0: //vgpr_a
59068                 return true;
59069               case 1: //vgpr_d0
59070                 return true;
59071               default:
59072                 fatal("op idx %i out of bounds\n", opIdx);
59073                 return false;
59074             }
59075         } // isSrcOperand
59076
59077         bool
59078         isDstOperand(int opIdx) override
59079         {
59080             switch (opIdx) {
59081               case 0: //vgpr_a
59082                 return false;
59083               case 1: //vgpr_d0
59084                 return false;
59085               default:
59086                 fatal("op idx %i out of bounds\n", opIdx);
59087                 return false;
59088             }
59089         } // isDstOperand
59090
59091         void execute(GPUDynInstPtr) override;
59092     }; // Inst_DS__DS_AND_B32
59093
59094     class Inst_DS__DS_OR_B32 : public Inst_DS
59095     {
59096       public:
59097         Inst_DS__DS_OR_B32(InFmt_DS*);
59098         ~Inst_DS__DS_OR_B32();
59099
59100         int
59101         getNumOperands() override
59102         {
59103             return numDstRegOperands() + numSrcRegOperands();
59104         } // getNumOperands
59105
59106         int numDstRegOperands() override { return 0; }
59107         int numSrcRegOperands() override { return 2; }
59108
59109         int
59110         getOperandSize(int opIdx) override
59111         {
59112             switch (opIdx) {
59113               case 0: //vgpr_a
59114                 return 4;
59115               case 1: //vgpr_d0
59116                 return 4;
59117               default:
59118                 fatal("op idx %i out of bounds\n", opIdx);
59119                 return -1;
59120             }
59121         } // getOperandSize
59122
59123         bool
59124         isSrcOperand(int opIdx) override
59125         {
59126             switch (opIdx) {
59127               case 0: //vgpr_a
59128                 return true;
59129               case 1: //vgpr_d0
59130                 return true;
59131               default:
59132                 fatal("op idx %i out of bounds\n", opIdx);
59133                 return false;
59134             }
59135         } // isSrcOperand
59136
59137         bool
59138         isDstOperand(int opIdx) override
59139         {
59140             switch (opIdx) {
59141               case 0: //vgpr_a
59142                 return false;
59143               case 1: //vgpr_d0
59144                 return false;
59145               default:
59146                 fatal("op idx %i out of bounds\n", opIdx);
59147                 return false;
59148             }
59149         } // isDstOperand
59150
59151         void execute(GPUDynInstPtr) override;
59152     }; // Inst_DS__DS_OR_B32
59153
59154     class Inst_DS__DS_XOR_B32 : public Inst_DS
59155     {
59156       public:
59157         Inst_DS__DS_XOR_B32(InFmt_DS*);
59158         ~Inst_DS__DS_XOR_B32();
59159
59160         int
59161         getNumOperands() override
59162         {
59163             return numDstRegOperands() + numSrcRegOperands();
59164         } // getNumOperands
59165
59166         int numDstRegOperands() override { return 0; }
59167         int numSrcRegOperands() override { return 2; }
59168
59169         int
59170         getOperandSize(int opIdx) override
59171         {
59172             switch (opIdx) {
59173               case 0: //vgpr_a
59174                 return 4;
59175               case 1: //vgpr_d0
59176                 return 4;
59177               default:
59178                 fatal("op idx %i out of bounds\n", opIdx);
59179                 return -1;
59180             }
59181         } // getOperandSize
59182
59183         bool
59184         isSrcOperand(int opIdx) override
59185         {
59186             switch (opIdx) {
59187               case 0: //vgpr_a
59188                 return true;
59189               case 1: //vgpr_d0
59190                 return true;
59191               default:
59192                 fatal("op idx %i out of bounds\n", opIdx);
59193                 return false;
59194             }
59195         } // isSrcOperand
59196
59197         bool
59198         isDstOperand(int opIdx) override
59199         {
59200             switch (opIdx) {
59201               case 0: //vgpr_a
59202                 return false;
59203               case 1: //vgpr_d0
59204                 return false;
59205               default:
59206                 fatal("op idx %i out of bounds\n", opIdx);
59207                 return false;
59208             }
59209         } // isDstOperand
59210
59211         void execute(GPUDynInstPtr) override;
59212     }; // Inst_DS__DS_XOR_B32
59213
59214     class Inst_DS__DS_MSKOR_B32 : public Inst_DS
59215     {
59216       public:
59217         Inst_DS__DS_MSKOR_B32(InFmt_DS*);
59218         ~Inst_DS__DS_MSKOR_B32();
59219
59220         int
59221         getNumOperands() override
59222         {
59223             return numDstRegOperands() + numSrcRegOperands();
59224         } // getNumOperands
59225
59226         int numDstRegOperands() override { return 0; }
59227         int numSrcRegOperands() override { return 3; }
59228
59229         int
59230         getOperandSize(int opIdx) override
59231         {
59232             switch (opIdx) {
59233               case 0: //vgpr_a
59234                 return 4;
59235               case 1: //vgpr_d1
59236                 return 4;
59237               default:
59238                 fatal("op idx %i out of bounds\n", opIdx);
59239                 return -1;
59240             }
59241         } // getOperandSize
59242
59243         bool
59244         isSrcOperand(int opIdx) override
59245         {
59246             switch (opIdx) {
59247               case 0: //vgpr_a
59248                 return true;
59249               case 1: //vgpr_d1
59250                 return true;
59251               default:
59252                 fatal("op idx %i out of bounds\n", opIdx);
59253                 return false;
59254             }
59255         } // isSrcOperand
59256
59257         bool
59258         isDstOperand(int opIdx) override
59259         {
59260             switch (opIdx) {
59261               case 0: //vgpr_a
59262                 return false;
59263               case 1: //vgpr_d1
59264                 return false;
59265               default:
59266                 fatal("op idx %i out of bounds\n", opIdx);
59267                 return false;
59268             }
59269         } // isDstOperand
59270
59271         void execute(GPUDynInstPtr) override;
59272     }; // Inst_DS__DS_MSKOR_B32
59273
59274     class Inst_DS__DS_WRITE_B32 : public Inst_DS
59275     {
59276       public:
59277         Inst_DS__DS_WRITE_B32(InFmt_DS*);
59278         ~Inst_DS__DS_WRITE_B32();
59279
59280         int
59281         getNumOperands() override
59282         {
59283             return numDstRegOperands() + numSrcRegOperands();
59284         } // getNumOperands
59285
59286         int numDstRegOperands() override { return 0; }
59287         int numSrcRegOperands() override { return 2; }
59288
59289         int
59290         getOperandSize(int opIdx) override
59291         {
59292             switch (opIdx) {
59293               case 0: //vgpr_a
59294                 return 4;
59295               case 1: //vgpr_d0
59296                 return 4;
59297               default:
59298                 fatal("op idx %i out of bounds\n", opIdx);
59299                 return -1;
59300             }
59301         } // getOperandSize
59302
59303         bool
59304         isSrcOperand(int opIdx) override
59305         {
59306             switch (opIdx) {
59307               case 0: //vgpr_a
59308                 return true;
59309               case 1: //vgpr_d0
59310                 return true;
59311               default:
59312                 fatal("op idx %i out of bounds\n", opIdx);
59313                 return false;
59314             }
59315         } // isSrcOperand
59316
59317         bool
59318         isDstOperand(int opIdx) override
59319         {
59320             switch (opIdx) {
59321               case 0: //vgpr_a
59322                 return false;
59323               case 1: //vgpr_d0
59324                 return false;
59325               default:
59326                 fatal("op idx %i out of bounds\n", opIdx);
59327                 return false;
59328             }
59329         } // isDstOperand
59330
59331         void execute(GPUDynInstPtr) override;
59332         void initiateAcc(GPUDynInstPtr) override;
59333         void completeAcc(GPUDynInstPtr) override;
59334     }; // Inst_DS__DS_WRITE_B32
59335
59336     class Inst_DS__DS_WRITE2_B32 : public Inst_DS
59337     {
59338       public:
59339         Inst_DS__DS_WRITE2_B32(InFmt_DS*);
59340         ~Inst_DS__DS_WRITE2_B32();
59341
59342         int
59343         getNumOperands() override
59344         {
59345             return numDstRegOperands() + numSrcRegOperands();
59346         } // getNumOperands
59347
59348         int numDstRegOperands() override { return 0; }
59349         int numSrcRegOperands() override { return 3; }
59350
59351         int
59352         getOperandSize(int opIdx) override
59353         {
59354             switch (opIdx) {
59355               case 0: //vgpr_a
59356                 return 4;
59357               case 1: //vgpr_d0
59358                 return 4;
59359               case 2: //vgpr_d1
59360                 return 4;
59361               default:
59362                 fatal("op idx %i out of bounds\n", opIdx);
59363                 return -1;
59364             }
59365         } // getOperandSize
59366
59367         bool
59368         isSrcOperand(int opIdx) override
59369         {
59370             switch (opIdx) {
59371               case 0: //vgpr_a
59372                 return true;
59373               case 1: //vgpr_d0
59374                 return true;
59375               case 2: //vgpr_d1
59376                 return true;
59377               default:
59378                 fatal("op idx %i out of bounds\n", opIdx);
59379                 return false;
59380             }
59381         } // isSrcOperand
59382
59383         bool
59384         isDstOperand(int opIdx) override
59385         {
59386             switch (opIdx) {
59387               case 0: //vgpr_a
59388                 return false;
59389               case 1: //vgpr_d0
59390                 return false;
59391               case 2: //vgpr_d1
59392                 return false;
59393               default:
59394                 fatal("op idx %i out of bounds\n", opIdx);
59395                 return false;
59396             }
59397         } // isDstOperand
59398
59399         void execute(GPUDynInstPtr) override;
59400         void initiateAcc(GPUDynInstPtr) override;
59401         void completeAcc(GPUDynInstPtr) override;
59402     }; // Inst_DS__DS_WRITE2_B32
59403
59404     class Inst_DS__DS_WRITE2ST64_B32 : public Inst_DS
59405     {
59406       public:
59407         Inst_DS__DS_WRITE2ST64_B32(InFmt_DS*);
59408         ~Inst_DS__DS_WRITE2ST64_B32();
59409
59410         int
59411         getNumOperands() override
59412         {
59413             return numDstRegOperands() + numSrcRegOperands();
59414         } // getNumOperands
59415
59416         int numDstRegOperands() override { return 0; }
59417         int numSrcRegOperands() override { return 3; }
59418
59419         int
59420         getOperandSize(int opIdx) override
59421         {
59422             switch (opIdx) {
59423               case 0: //vgpr_a
59424                 return 4;
59425               case 1: //vgpr_d0
59426                 return 4;
59427               case 2: //vgpr_d1
59428                 return 4;
59429               default:
59430                 fatal("op idx %i out of bounds\n", opIdx);
59431                 return -1;
59432             }
59433         } // getOperandSize
59434
59435         bool
59436         isSrcOperand(int opIdx) override
59437         {
59438             switch (opIdx) {
59439               case 0: //vgpr_a
59440                 return true;
59441               case 1: //vgpr_d0
59442                 return true;
59443               case 2: //vgpr_d1
59444                 return true;
59445               default:
59446                 fatal("op idx %i out of bounds\n", opIdx);
59447                 return false;
59448             }
59449         } // isSrcOperand
59450
59451         bool
59452         isDstOperand(int opIdx) override
59453         {
59454             switch (opIdx) {
59455               case 0: //vgpr_a
59456                 return false;
59457               case 1: //vgpr_d0
59458                 return false;
59459               case 2: //vgpr_d1
59460                 return false;
59461               default:
59462                 fatal("op idx %i out of bounds\n", opIdx);
59463                 return false;
59464             }
59465         } // isDstOperand
59466
59467         void execute(GPUDynInstPtr) override;
59468         void initiateAcc(GPUDynInstPtr) override;
59469         void completeAcc(GPUDynInstPtr) override;
59470     }; // Inst_DS__DS_WRITE2ST64_B32
59471
59472     class Inst_DS__DS_CMPST_B32 : public Inst_DS
59473     {
59474       public:
59475         Inst_DS__DS_CMPST_B32(InFmt_DS*);
59476         ~Inst_DS__DS_CMPST_B32();
59477
59478         int
59479         getNumOperands() override
59480         {
59481             return numDstRegOperands() + numSrcRegOperands();
59482         } // getNumOperands
59483
59484         int numDstRegOperands() override { return 0; }
59485         int numSrcRegOperands() override { return 3; }
59486
59487         int
59488         getOperandSize(int opIdx) override
59489         {
59490             switch (opIdx) {
59491               case 0: //vgpr_a
59492                 return 4;
59493               case 1: //vgpr_d1
59494                 return 4;
59495               default:
59496                 fatal("op idx %i out of bounds\n", opIdx);
59497                 return -1;
59498             }
59499         } // getOperandSize
59500
59501         bool
59502         isSrcOperand(int opIdx) override
59503         {
59504             switch (opIdx) {
59505               case 0: //vgpr_a
59506                 return true;
59507               case 1: //vgpr_d1
59508                 return true;
59509               default:
59510                 fatal("op idx %i out of bounds\n", opIdx);
59511                 return false;
59512             }
59513         } // isSrcOperand
59514
59515         bool
59516         isDstOperand(int opIdx) override
59517         {
59518             switch (opIdx) {
59519               case 0: //vgpr_a
59520                 return false;
59521               case 1: //vgpr_d1
59522                 return false;
59523               default:
59524                 fatal("op idx %i out of bounds\n", opIdx);
59525                 return false;
59526             }
59527         } // isDstOperand
59528
59529         void execute(GPUDynInstPtr) override;
59530     }; // Inst_DS__DS_CMPST_B32
59531
59532     class Inst_DS__DS_CMPST_F32 : public Inst_DS
59533     {
59534       public:
59535         Inst_DS__DS_CMPST_F32(InFmt_DS*);
59536         ~Inst_DS__DS_CMPST_F32();
59537
59538         int
59539         getNumOperands() override
59540         {
59541             return numDstRegOperands() + numSrcRegOperands();
59542         } // getNumOperands
59543
59544         int numDstRegOperands() override { return 0; }
59545         int numSrcRegOperands() override { return 3; }
59546
59547         int
59548         getOperandSize(int opIdx) override
59549         {
59550             switch (opIdx) {
59551               case 0: //vgpr_a
59552                 return 4;
59553               case 1: //vgpr_d1
59554                 return 4;
59555               default:
59556                 fatal("op idx %i out of bounds\n", opIdx);
59557                 return -1;
59558             }
59559         } // getOperandSize
59560
59561         bool
59562         isSrcOperand(int opIdx) override
59563         {
59564             switch (opIdx) {
59565               case 0: //vgpr_a
59566                 return true;
59567               case 1: //vgpr_d1
59568                 return true;
59569               default:
59570                 fatal("op idx %i out of bounds\n", opIdx);
59571                 return false;
59572             }
59573         } // isSrcOperand
59574
59575         bool
59576         isDstOperand(int opIdx) override
59577         {
59578             switch (opIdx) {
59579               case 0: //vgpr_a
59580                 return false;
59581               case 1: //vgpr_d1
59582                 return false;
59583               default:
59584                 fatal("op idx %i out of bounds\n", opIdx);
59585                 return false;
59586             }
59587         } // isDstOperand
59588
59589         void execute(GPUDynInstPtr) override;
59590     }; // Inst_DS__DS_CMPST_F32
59591
59592     class Inst_DS__DS_MIN_F32 : public Inst_DS
59593     {
59594       public:
59595         Inst_DS__DS_MIN_F32(InFmt_DS*);
59596         ~Inst_DS__DS_MIN_F32();
59597
59598         int
59599         getNumOperands() override
59600         {
59601             return numDstRegOperands() + numSrcRegOperands();
59602         } // getNumOperands
59603
59604         int numDstRegOperands() override { return 0; }
59605         int numSrcRegOperands() override { return 2; }
59606
59607         int
59608         getOperandSize(int opIdx) override
59609         {
59610             switch (opIdx) {
59611               case 0: //vgpr_a
59612                 return 4;
59613               case 1: //vgpr_d0
59614                 return 4;
59615               default:
59616                 fatal("op idx %i out of bounds\n", opIdx);
59617                 return -1;
59618             }
59619         } // getOperandSize
59620
59621         bool
59622         isSrcOperand(int opIdx) override
59623         {
59624             switch (opIdx) {
59625               case 0: //vgpr_a
59626                 return true;
59627               case 1: //vgpr_d0
59628                 return true;
59629               default:
59630                 fatal("op idx %i out of bounds\n", opIdx);
59631                 return false;
59632             }
59633         } // isSrcOperand
59634
59635         bool
59636         isDstOperand(int opIdx) override
59637         {
59638             switch (opIdx) {
59639               case 0: //vgpr_a
59640                 return false;
59641               case 1: //vgpr_d0
59642                 return false;
59643               default:
59644                 fatal("op idx %i out of bounds\n", opIdx);
59645                 return false;
59646             }
59647         } // isDstOperand
59648
59649         void execute(GPUDynInstPtr) override;
59650     }; // Inst_DS__DS_MIN_F32
59651
59652     class Inst_DS__DS_MAX_F32 : public Inst_DS
59653     {
59654       public:
59655         Inst_DS__DS_MAX_F32(InFmt_DS*);
59656         ~Inst_DS__DS_MAX_F32();
59657
59658         int
59659         getNumOperands() override
59660         {
59661             return numDstRegOperands() + numSrcRegOperands();
59662         } // getNumOperands
59663
59664         int numDstRegOperands() override { return 0; }
59665         int numSrcRegOperands() override { return 2; }
59666
59667         int
59668         getOperandSize(int opIdx) override
59669         {
59670             switch (opIdx) {
59671               case 0: //vgpr_a
59672                 return 4;
59673               case 1: //vgpr_d0
59674                 return 4;
59675               default:
59676                 fatal("op idx %i out of bounds\n", opIdx);
59677                 return -1;
59678             }
59679         } // getOperandSize
59680
59681         bool
59682         isSrcOperand(int opIdx) override
59683         {
59684             switch (opIdx) {
59685               case 0: //vgpr_a
59686                 return true;
59687               case 1: //vgpr_d0
59688                 return true;
59689               default:
59690                 fatal("op idx %i out of bounds\n", opIdx);
59691                 return false;
59692             }
59693         } // isSrcOperand
59694
59695         bool
59696         isDstOperand(int opIdx) override
59697         {
59698             switch (opIdx) {
59699               case 0: //vgpr_a
59700                 return false;
59701               case 1: //vgpr_d0
59702                 return false;
59703               default:
59704                 fatal("op idx %i out of bounds\n", opIdx);
59705                 return false;
59706             }
59707         } // isDstOperand
59708
59709         void execute(GPUDynInstPtr) override;
59710     }; // Inst_DS__DS_MAX_F32
59711
59712     class Inst_DS__DS_NOP : public Inst_DS
59713     {
59714       public:
59715         Inst_DS__DS_NOP(InFmt_DS*);
59716         ~Inst_DS__DS_NOP();
59717
59718         int
59719         getNumOperands() override
59720         {
59721             return numDstRegOperands() + numSrcRegOperands();
59722         } // getNumOperands
59723
59724         int numDstRegOperands() override { return 0; }
59725         int numSrcRegOperands() override { return 0; }
59726
59727         int
59728         getOperandSize(int opIdx) override
59729         {
59730             switch (opIdx) {
59731               case 0: //vgpr_a
59732                 return 4;
59733               default:
59734                 fatal("op idx %i out of bounds\n", opIdx);
59735                 return -1;
59736             }
59737         } // getOperandSize
59738
59739         bool
59740         isSrcOperand(int opIdx) override
59741         {
59742             switch (opIdx) {
59743               case 0: //vgpr_a
59744                 return true;
59745               default:
59746                 fatal("op idx %i out of bounds\n", opIdx);
59747                 return false;
59748             }
59749         } // isSrcOperand
59750
59751         bool
59752         isDstOperand(int opIdx) override
59753         {
59754             switch (opIdx) {
59755               case 0: //vgpr_a
59756                 return false;
59757               default:
59758                 fatal("op idx %i out of bounds\n", opIdx);
59759                 return false;
59760             }
59761         } // isDstOperand
59762
59763         void execute(GPUDynInstPtr) override;
59764     }; // Inst_DS__DS_NOP
59765
59766     class Inst_DS__DS_ADD_F32 : public Inst_DS
59767     {
59768       public:
59769         Inst_DS__DS_ADD_F32(InFmt_DS*);
59770         ~Inst_DS__DS_ADD_F32();
59771
59772         int
59773         getNumOperands() override
59774         {
59775             return numDstRegOperands() + numSrcRegOperands();
59776         } // getNumOperands
59777
59778         int numDstRegOperands() override { return 0; }
59779         int numSrcRegOperands() override { return 2; }
59780
59781         int
59782         getOperandSize(int opIdx) override
59783         {
59784             switch (opIdx) {
59785               case 0: //vgpr_a
59786                 return 4;
59787               case 1: //vgpr_d0
59788                 return 4;
59789               default:
59790                 fatal("op idx %i out of bounds\n", opIdx);
59791                 return -1;
59792             }
59793         } // getOperandSize
59794
59795         bool
59796         isSrcOperand(int opIdx) override
59797         {
59798             switch (opIdx) {
59799               case 0: //vgpr_a
59800                 return true;
59801               case 1: //vgpr_d0
59802                 return true;
59803               default:
59804                 fatal("op idx %i out of bounds\n", opIdx);
59805                 return false;
59806             }
59807         } // isSrcOperand
59808
59809         bool
59810         isDstOperand(int opIdx) override
59811         {
59812             switch (opIdx) {
59813               case 0: //vgpr_a
59814                 return false;
59815               case 1: //vgpr_d0
59816                 return false;
59817               default:
59818                 fatal("op idx %i out of bounds\n", opIdx);
59819                 return false;
59820             }
59821         } // isDstOperand
59822
59823         void execute(GPUDynInstPtr) override;
59824     }; // Inst_DS__DS_ADD_F32
59825
59826     class Inst_DS__DS_WRITE_B8 : public Inst_DS
59827     {
59828       public:
59829         Inst_DS__DS_WRITE_B8(InFmt_DS*);
59830         ~Inst_DS__DS_WRITE_B8();
59831
59832         int
59833         getNumOperands() override
59834         {
59835             return numDstRegOperands() + numSrcRegOperands();
59836         } // getNumOperands
59837
59838         int numDstRegOperands() override { return 0; }
59839         int numSrcRegOperands() override { return 2; }
59840
59841         int
59842         getOperandSize(int opIdx) override
59843         {
59844             switch (opIdx) {
59845               case 0: //vgpr_a
59846                 return 4;
59847               case 1: //vgpr_d0
59848                 return 1;
59849               default:
59850                 fatal("op idx %i out of bounds\n", opIdx);
59851                 return -1;
59852             }
59853         } // getOperandSize
59854
59855         bool
59856         isSrcOperand(int opIdx) override
59857         {
59858             switch (opIdx) {
59859               case 0: //vgpr_a
59860                 return true;
59861               case 1: //vgpr_d0
59862                 return true;
59863               default:
59864                 fatal("op idx %i out of bounds\n", opIdx);
59865                 return false;
59866             }
59867         } // isSrcOperand
59868
59869         bool
59870         isDstOperand(int opIdx) override
59871         {
59872             switch (opIdx) {
59873               case 0: //vgpr_a
59874                 return false;
59875               case 1: //vgpr_d0
59876                 return false;
59877               default:
59878                 fatal("op idx %i out of bounds\n", opIdx);
59879                 return false;
59880             }
59881         } // isDstOperand
59882
59883         void execute(GPUDynInstPtr) override;
59884         void initiateAcc(GPUDynInstPtr) override;
59885         void completeAcc(GPUDynInstPtr) override;
59886     }; // Inst_DS__DS_WRITE_B8
59887
59888     class Inst_DS__DS_WRITE_B16 : public Inst_DS
59889     {
59890       public:
59891         Inst_DS__DS_WRITE_B16(InFmt_DS*);
59892         ~Inst_DS__DS_WRITE_B16();
59893
59894         int
59895         getNumOperands() override
59896         {
59897             return numDstRegOperands() + numSrcRegOperands();
59898         } // getNumOperands
59899
59900         int numDstRegOperands() override { return 0; }
59901         int numSrcRegOperands() override { return 2; }
59902
59903         int
59904         getOperandSize(int opIdx) override
59905         {
59906             switch (opIdx) {
59907               case 0: //vgpr_a
59908                 return 4;
59909               case 1: //vgpr_d0
59910                 return 2;
59911               default:
59912                 fatal("op idx %i out of bounds\n", opIdx);
59913                 return -1;
59914             }
59915         } // getOperandSize
59916
59917         bool
59918         isSrcOperand(int opIdx) override
59919         {
59920             switch (opIdx) {
59921               case 0: //vgpr_a
59922                 return true;
59923               case 1: //vgpr_d0
59924                 return true;
59925               default:
59926                 fatal("op idx %i out of bounds\n", opIdx);
59927                 return false;
59928             }
59929         } // isSrcOperand
59930
59931         bool
59932         isDstOperand(int opIdx) override
59933         {
59934             switch (opIdx) {
59935               case 0: //vgpr_a
59936                 return false;
59937               case 1: //vgpr_d0
59938                 return false;
59939               default:
59940                 fatal("op idx %i out of bounds\n", opIdx);
59941                 return false;
59942             }
59943         } // isDstOperand
59944
59945         void execute(GPUDynInstPtr) override;
59946         void initiateAcc(GPUDynInstPtr) override;
59947         void completeAcc(GPUDynInstPtr) override;
59948     }; // Inst_DS__DS_WRITE_B16
59949
59950     class Inst_DS__DS_ADD_RTN_U32 : public Inst_DS
59951     {
59952       public:
59953         Inst_DS__DS_ADD_RTN_U32(InFmt_DS*);
59954         ~Inst_DS__DS_ADD_RTN_U32();
59955
59956         int
59957         getNumOperands() override
59958         {
59959             return numDstRegOperands() + numSrcRegOperands();
59960         } // getNumOperands
59961
59962         int numDstRegOperands() override { return 1; }
59963         int numSrcRegOperands() override { return 2; }
59964
59965         int
59966         getOperandSize(int opIdx) override
59967         {
59968             switch (opIdx) {
59969               case 0: //vgpr_a
59970                 return 4;
59971               case 1: //vgpr_d0
59972                 return 4;
59973               case 2: //vgpr_rtn
59974                 return 4;
59975               default:
59976                 fatal("op idx %i out of bounds\n", opIdx);
59977                 return -1;
59978             }
59979         } // getOperandSize
59980
59981         bool
59982         isSrcOperand(int opIdx) override
59983         {
59984             switch (opIdx) {
59985               case 0: //vgpr_a
59986                 return true;
59987               case 1: //vgpr_d0
59988                 return true;
59989               case 2: //vgpr_rtn
59990                 return false;
59991               default:
59992                 fatal("op idx %i out of bounds\n", opIdx);
59993                 return false;
59994             }
59995         } // isSrcOperand
59996
59997         bool
59998         isDstOperand(int opIdx) override
59999         {
60000             switch (opIdx) {
60001               case 0: //vgpr_a
60002                 return false;
60003               case 1: //vgpr_d0
60004                 return false;
60005               case 2: //vgpr_rtn
60006                 return true;
60007               default:
60008                 fatal("op idx %i out of bounds\n", opIdx);
60009                 return false;
60010             }
60011         } // isDstOperand
60012
60013         void execute(GPUDynInstPtr) override;
60014     }; // Inst_DS__DS_ADD_RTN_U32
60015
60016     class Inst_DS__DS_SUB_RTN_U32 : public Inst_DS
60017     {
60018       public:
60019         Inst_DS__DS_SUB_RTN_U32(InFmt_DS*);
60020         ~Inst_DS__DS_SUB_RTN_U32();
60021
60022         int
60023         getNumOperands() override
60024         {
60025             return numDstRegOperands() + numSrcRegOperands();
60026         } // getNumOperands
60027
60028         int numDstRegOperands() override { return 1; }
60029         int numSrcRegOperands() override { return 2; }
60030
60031         int
60032         getOperandSize(int opIdx) override
60033         {
60034             switch (opIdx) {
60035               case 0: //vgpr_a
60036                 return 4;
60037               case 1: //vgpr_d0
60038                 return 4;
60039               case 2: //vgpr_rtn
60040                 return 4;
60041               default:
60042                 fatal("op idx %i out of bounds\n", opIdx);
60043                 return -1;
60044             }
60045         } // getOperandSize
60046
60047         bool
60048         isSrcOperand(int opIdx) override
60049         {
60050             switch (opIdx) {
60051               case 0: //vgpr_a
60052                 return true;
60053               case 1: //vgpr_d0
60054                 return true;
60055               case 2: //vgpr_rtn
60056                 return false;
60057               default:
60058                 fatal("op idx %i out of bounds\n", opIdx);
60059                 return false;
60060             }
60061         } // isSrcOperand
60062
60063         bool
60064         isDstOperand(int opIdx) override
60065         {
60066             switch (opIdx) {
60067               case 0: //vgpr_a
60068                 return false;
60069               case 1: //vgpr_d0
60070                 return false;
60071               case 2: //vgpr_rtn
60072                 return true;
60073               default:
60074                 fatal("op idx %i out of bounds\n", opIdx);
60075                 return false;
60076             }
60077         } // isDstOperand
60078
60079         void execute(GPUDynInstPtr) override;
60080     }; // Inst_DS__DS_SUB_RTN_U32
60081
60082     class Inst_DS__DS_RSUB_RTN_U32 : public Inst_DS
60083     {
60084       public:
60085         Inst_DS__DS_RSUB_RTN_U32(InFmt_DS*);
60086         ~Inst_DS__DS_RSUB_RTN_U32();
60087
60088         int
60089         getNumOperands() override
60090         {
60091             return numDstRegOperands() + numSrcRegOperands();
60092         } // getNumOperands
60093
60094         int numDstRegOperands() override { return 1; }
60095         int numSrcRegOperands() override { return 2; }
60096
60097         int
60098         getOperandSize(int opIdx) override
60099         {
60100             switch (opIdx) {
60101               case 0: //vgpr_a
60102                 return 4;
60103               case 1: //vgpr_d0
60104                 return 4;
60105               case 2: //vgpr_rtn
60106                 return 4;
60107               default:
60108                 fatal("op idx %i out of bounds\n", opIdx);
60109                 return -1;
60110             }
60111         } // getOperandSize
60112
60113         bool
60114         isSrcOperand(int opIdx) override
60115         {
60116             switch (opIdx) {
60117               case 0: //vgpr_a
60118                 return true;
60119               case 1: //vgpr_d0
60120                 return true;
60121               case 2: //vgpr_rtn
60122                 return false;
60123               default:
60124                 fatal("op idx %i out of bounds\n", opIdx);
60125                 return false;
60126             }
60127         } // isSrcOperand
60128
60129         bool
60130         isDstOperand(int opIdx) override
60131         {
60132             switch (opIdx) {
60133               case 0: //vgpr_a
60134                 return false;
60135               case 1: //vgpr_d0
60136                 return false;
60137               case 2: //vgpr_rtn
60138                 return true;
60139               default:
60140                 fatal("op idx %i out of bounds\n", opIdx);
60141                 return false;
60142             }
60143         } // isDstOperand
60144
60145         void execute(GPUDynInstPtr) override;
60146     }; // Inst_DS__DS_RSUB_RTN_U32
60147
60148     class Inst_DS__DS_INC_RTN_U32 : public Inst_DS
60149     {
60150       public:
60151         Inst_DS__DS_INC_RTN_U32(InFmt_DS*);
60152         ~Inst_DS__DS_INC_RTN_U32();
60153
60154         int
60155         getNumOperands() override
60156         {
60157             return numDstRegOperands() + numSrcRegOperands();
60158         } // getNumOperands
60159
60160         int numDstRegOperands() override { return 1; }
60161         int numSrcRegOperands() override { return 2; }
60162
60163         int
60164         getOperandSize(int opIdx) override
60165         {
60166             switch (opIdx) {
60167               case 0: //vgpr_a
60168                 return 4;
60169               case 1: //vgpr_d0
60170                 return 4;
60171               case 2: //vgpr_rtn
60172                 return 4;
60173               default:
60174                 fatal("op idx %i out of bounds\n", opIdx);
60175                 return -1;
60176             }
60177         } // getOperandSize
60178
60179         bool
60180         isSrcOperand(int opIdx) override
60181         {
60182             switch (opIdx) {
60183               case 0: //vgpr_a
60184                 return true;
60185               case 1: //vgpr_d0
60186                 return true;
60187               case 2: //vgpr_rtn
60188                 return false;
60189               default:
60190                 fatal("op idx %i out of bounds\n", opIdx);
60191                 return false;
60192             }
60193         } // isSrcOperand
60194
60195         bool
60196         isDstOperand(int opIdx) override
60197         {
60198             switch (opIdx) {
60199               case 0: //vgpr_a
60200                 return false;
60201               case 1: //vgpr_d0
60202                 return false;
60203               case 2: //vgpr_rtn
60204                 return true;
60205               default:
60206                 fatal("op idx %i out of bounds\n", opIdx);
60207                 return false;
60208             }
60209         } // isDstOperand
60210
60211         void execute(GPUDynInstPtr) override;
60212     }; // Inst_DS__DS_INC_RTN_U32
60213
60214     class Inst_DS__DS_DEC_RTN_U32 : public Inst_DS
60215     {
60216       public:
60217         Inst_DS__DS_DEC_RTN_U32(InFmt_DS*);
60218         ~Inst_DS__DS_DEC_RTN_U32();
60219
60220         int
60221         getNumOperands() override
60222         {
60223             return numDstRegOperands() + numSrcRegOperands();
60224         } // getNumOperands
60225
60226         int numDstRegOperands() override { return 1; }
60227         int numSrcRegOperands() override { return 2; }
60228
60229         int
60230         getOperandSize(int opIdx) override
60231         {
60232             switch (opIdx) {
60233               case 0: //vgpr_a
60234                 return 4;
60235               case 1: //vgpr_d0
60236                 return 4;
60237               case 2: //vgpr_rtn
60238                 return 4;
60239               default:
60240                 fatal("op idx %i out of bounds\n", opIdx);
60241                 return -1;
60242             }
60243         } // getOperandSize
60244
60245         bool
60246         isSrcOperand(int opIdx) override
60247         {
60248             switch (opIdx) {
60249               case 0: //vgpr_a
60250                 return true;
60251               case 1: //vgpr_d0
60252                 return true;
60253               case 2: //vgpr_rtn
60254                 return false;
60255               default:
60256                 fatal("op idx %i out of bounds\n", opIdx);
60257                 return false;
60258             }
60259         } // isSrcOperand
60260
60261         bool
60262         isDstOperand(int opIdx) override
60263         {
60264             switch (opIdx) {
60265               case 0: //vgpr_a
60266                 return false;
60267               case 1: //vgpr_d0
60268                 return false;
60269               case 2: //vgpr_rtn
60270                 return true;
60271               default:
60272                 fatal("op idx %i out of bounds\n", opIdx);
60273                 return false;
60274             }
60275         } // isDstOperand
60276
60277         void execute(GPUDynInstPtr) override;
60278     }; // Inst_DS__DS_DEC_RTN_U32
60279
60280     class Inst_DS__DS_MIN_RTN_I32 : public Inst_DS
60281     {
60282       public:
60283         Inst_DS__DS_MIN_RTN_I32(InFmt_DS*);
60284         ~Inst_DS__DS_MIN_RTN_I32();
60285
60286         int
60287         getNumOperands() override
60288         {
60289             return numDstRegOperands() + numSrcRegOperands();
60290         } // getNumOperands
60291
60292         int numDstRegOperands() override { return 1; }
60293         int numSrcRegOperands() override { return 2; }
60294
60295         int
60296         getOperandSize(int opIdx) override
60297         {
60298             switch (opIdx) {
60299               case 0: //vgpr_a
60300                 return 4;
60301               case 1: //vgpr_d0
60302                 return 4;
60303               case 2: //vgpr_rtn
60304                 return 4;
60305               default:
60306                 fatal("op idx %i out of bounds\n", opIdx);
60307                 return -1;
60308             }
60309         } // getOperandSize
60310
60311         bool
60312         isSrcOperand(int opIdx) override
60313         {
60314             switch (opIdx) {
60315               case 0: //vgpr_a
60316                 return true;
60317               case 1: //vgpr_d0
60318                 return true;
60319               case 2: //vgpr_rtn
60320                 return false;
60321               default:
60322                 fatal("op idx %i out of bounds\n", opIdx);
60323                 return false;
60324             }
60325         } // isSrcOperand
60326
60327         bool
60328         isDstOperand(int opIdx) override
60329         {
60330             switch (opIdx) {
60331               case 0: //vgpr_a
60332                 return false;
60333               case 1: //vgpr_d0
60334                 return false;
60335               case 2: //vgpr_rtn
60336                 return true;
60337               default:
60338                 fatal("op idx %i out of bounds\n", opIdx);
60339                 return false;
60340             }
60341         } // isDstOperand
60342
60343         void execute(GPUDynInstPtr) override;
60344     }; // Inst_DS__DS_MIN_RTN_I32
60345
60346     class Inst_DS__DS_MAX_RTN_I32 : public Inst_DS
60347     {
60348       public:
60349         Inst_DS__DS_MAX_RTN_I32(InFmt_DS*);
60350         ~Inst_DS__DS_MAX_RTN_I32();
60351
60352         int
60353         getNumOperands() override
60354         {
60355             return numDstRegOperands() + numSrcRegOperands();
60356         } // getNumOperands
60357
60358         int numDstRegOperands() override { return 1; }
60359         int numSrcRegOperands() override { return 2; }
60360
60361         int
60362         getOperandSize(int opIdx) override
60363         {
60364             switch (opIdx) {
60365               case 0: //vgpr_a
60366                 return 4;
60367               case 1: //vgpr_d0
60368                 return 4;
60369               case 2: //vgpr_rtn
60370                 return 4;
60371               default:
60372                 fatal("op idx %i out of bounds\n", opIdx);
60373                 return -1;
60374             }
60375         } // getOperandSize
60376
60377         bool
60378         isSrcOperand(int opIdx) override
60379         {
60380             switch (opIdx) {
60381               case 0: //vgpr_a
60382                 return true;
60383               case 1: //vgpr_d0
60384                 return true;
60385               case 2: //vgpr_rtn
60386                 return false;
60387               default:
60388                 fatal("op idx %i out of bounds\n", opIdx);
60389                 return false;
60390             }
60391         } // isSrcOperand
60392
60393         bool
60394         isDstOperand(int opIdx) override
60395         {
60396             switch (opIdx) {
60397               case 0: //vgpr_a
60398                 return false;
60399               case 1: //vgpr_d0
60400                 return false;
60401               case 2: //vgpr_rtn
60402                 return true;
60403               default:
60404                 fatal("op idx %i out of bounds\n", opIdx);
60405                 return false;
60406             }
60407         } // isDstOperand
60408
60409         void execute(GPUDynInstPtr) override;
60410     }; // Inst_DS__DS_MAX_RTN_I32
60411
60412     class Inst_DS__DS_MIN_RTN_U32 : public Inst_DS
60413     {
60414       public:
60415         Inst_DS__DS_MIN_RTN_U32(InFmt_DS*);
60416         ~Inst_DS__DS_MIN_RTN_U32();
60417
60418         int
60419         getNumOperands() override
60420         {
60421             return numDstRegOperands() + numSrcRegOperands();
60422         } // getNumOperands
60423
60424         int numDstRegOperands() override { return 1; }
60425         int numSrcRegOperands() override { return 2; }
60426
60427         int
60428         getOperandSize(int opIdx) override
60429         {
60430             switch (opIdx) {
60431               case 0: //vgpr_a
60432                 return 4;
60433               case 1: //vgpr_d0
60434                 return 4;
60435               case 2: //vgpr_rtn
60436                 return 4;
60437               default:
60438                 fatal("op idx %i out of bounds\n", opIdx);
60439                 return -1;
60440             }
60441         } // getOperandSize
60442
60443         bool
60444         isSrcOperand(int opIdx) override
60445         {
60446             switch (opIdx) {
60447               case 0: //vgpr_a
60448                 return true;
60449               case 1: //vgpr_d0
60450                 return true;
60451               case 2: //vgpr_rtn
60452                 return false;
60453               default:
60454                 fatal("op idx %i out of bounds\n", opIdx);
60455                 return false;
60456             }
60457         } // isSrcOperand
60458
60459         bool
60460         isDstOperand(int opIdx) override
60461         {
60462             switch (opIdx) {
60463               case 0: //vgpr_a
60464                 return false;
60465               case 1: //vgpr_d0
60466                 return false;
60467               case 2: //vgpr_rtn
60468                 return true;
60469               default:
60470                 fatal("op idx %i out of bounds\n", opIdx);
60471                 return false;
60472             }
60473         } // isDstOperand
60474
60475         void execute(GPUDynInstPtr) override;
60476     }; // Inst_DS__DS_MIN_RTN_U32
60477
60478     class Inst_DS__DS_MAX_RTN_U32 : public Inst_DS
60479     {
60480       public:
60481         Inst_DS__DS_MAX_RTN_U32(InFmt_DS*);
60482         ~Inst_DS__DS_MAX_RTN_U32();
60483
60484         int
60485         getNumOperands() override
60486         {
60487             return numDstRegOperands() + numSrcRegOperands();
60488         } // getNumOperands
60489
60490         int numDstRegOperands() override { return 1; }
60491         int numSrcRegOperands() override { return 2; }
60492
60493         int
60494         getOperandSize(int opIdx) override
60495         {
60496             switch (opIdx) {
60497               case 0: //vgpr_a
60498                 return 4;
60499               case 1: //vgpr_d0
60500                 return 4;
60501               case 2: //vgpr_rtn
60502                 return 4;
60503               default:
60504                 fatal("op idx %i out of bounds\n", opIdx);
60505                 return -1;
60506             }
60507         } // getOperandSize
60508
60509         bool
60510         isSrcOperand(int opIdx) override
60511         {
60512             switch (opIdx) {
60513               case 0: //vgpr_a
60514                 return true;
60515               case 1: //vgpr_d0
60516                 return true;
60517               case 2: //vgpr_rtn
60518                 return false;
60519               default:
60520                 fatal("op idx %i out of bounds\n", opIdx);
60521                 return false;
60522             }
60523         } // isSrcOperand
60524
60525         bool
60526         isDstOperand(int opIdx) override
60527         {
60528             switch (opIdx) {
60529               case 0: //vgpr_a
60530                 return false;
60531               case 1: //vgpr_d0
60532                 return false;
60533               case 2: //vgpr_rtn
60534                 return true;
60535               default:
60536                 fatal("op idx %i out of bounds\n", opIdx);
60537                 return false;
60538             }
60539         } // isDstOperand
60540
60541         void execute(GPUDynInstPtr) override;
60542     }; // Inst_DS__DS_MAX_RTN_U32
60543
60544     class Inst_DS__DS_AND_RTN_B32 : public Inst_DS
60545     {
60546       public:
60547         Inst_DS__DS_AND_RTN_B32(InFmt_DS*);
60548         ~Inst_DS__DS_AND_RTN_B32();
60549
60550         int
60551         getNumOperands() override
60552         {
60553             return numDstRegOperands() + numSrcRegOperands();
60554         } // getNumOperands
60555
60556         int numDstRegOperands() override { return 1; }
60557         int numSrcRegOperands() override { return 2; }
60558
60559         int
60560         getOperandSize(int opIdx) override
60561         {
60562             switch (opIdx) {
60563               case 0: //vgpr_a
60564                 return 4;
60565               case 1: //vgpr_d0
60566                 return 4;
60567               case 2: //vgpr_rtn
60568                 return 4;
60569               default:
60570                 fatal("op idx %i out of bounds\n", opIdx);
60571                 return -1;
60572             }
60573         } // getOperandSize
60574
60575         bool
60576         isSrcOperand(int opIdx) override
60577         {
60578             switch (opIdx) {
60579               case 0: //vgpr_a
60580                 return true;
60581               case 1: //vgpr_d0
60582                 return true;
60583               case 2: //vgpr_rtn
60584                 return false;
60585               default:
60586                 fatal("op idx %i out of bounds\n", opIdx);
60587                 return false;
60588             }
60589         } // isSrcOperand
60590
60591         bool
60592         isDstOperand(int opIdx) override
60593         {
60594             switch (opIdx) {
60595               case 0: //vgpr_a
60596                 return false;
60597               case 1: //vgpr_d0
60598                 return false;
60599               case 2: //vgpr_rtn
60600                 return true;
60601               default:
60602                 fatal("op idx %i out of bounds\n", opIdx);
60603                 return false;
60604             }
60605         } // isDstOperand
60606
60607         void execute(GPUDynInstPtr) override;
60608     }; // Inst_DS__DS_AND_RTN_B32
60609
60610     class Inst_DS__DS_OR_RTN_B32 : public Inst_DS
60611     {
60612       public:
60613         Inst_DS__DS_OR_RTN_B32(InFmt_DS*);
60614         ~Inst_DS__DS_OR_RTN_B32();
60615
60616         int
60617         getNumOperands() override
60618         {
60619             return numDstRegOperands() + numSrcRegOperands();
60620         } // getNumOperands
60621
60622         int numDstRegOperands() override { return 1; }
60623         int numSrcRegOperands() override { return 2; }
60624
60625         int
60626         getOperandSize(int opIdx) override
60627         {
60628             switch (opIdx) {
60629               case 0: //vgpr_a
60630                 return 4;
60631               case 1: //vgpr_d0
60632                 return 4;
60633               case 2: //vgpr_rtn
60634                 return 4;
60635               default:
60636                 fatal("op idx %i out of bounds\n", opIdx);
60637                 return -1;
60638             }
60639         } // getOperandSize
60640
60641         bool
60642         isSrcOperand(int opIdx) override
60643         {
60644             switch (opIdx) {
60645               case 0: //vgpr_a
60646                 return true;
60647               case 1: //vgpr_d0
60648                 return true;
60649               case 2: //vgpr_rtn
60650                 return false;
60651               default:
60652                 fatal("op idx %i out of bounds\n", opIdx);
60653                 return false;
60654             }
60655         } // isSrcOperand
60656
60657         bool
60658         isDstOperand(int opIdx) override
60659         {
60660             switch (opIdx) {
60661               case 0: //vgpr_a
60662                 return false;
60663               case 1: //vgpr_d0
60664                 return false;
60665               case 2: //vgpr_rtn
60666                 return true;
60667               default:
60668                 fatal("op idx %i out of bounds\n", opIdx);
60669                 return false;
60670             }
60671         } // isDstOperand
60672
60673         void execute(GPUDynInstPtr) override;
60674     }; // Inst_DS__DS_OR_RTN_B32
60675
60676     class Inst_DS__DS_XOR_RTN_B32 : public Inst_DS
60677     {
60678       public:
60679         Inst_DS__DS_XOR_RTN_B32(InFmt_DS*);
60680         ~Inst_DS__DS_XOR_RTN_B32();
60681
60682         int
60683         getNumOperands() override
60684         {
60685             return numDstRegOperands() + numSrcRegOperands();
60686         } // getNumOperands
60687
60688         int numDstRegOperands() override { return 1; }
60689         int numSrcRegOperands() override { return 2; }
60690
60691         int
60692         getOperandSize(int opIdx) override
60693         {
60694             switch (opIdx) {
60695               case 0: //vgpr_a
60696                 return 4;
60697               case 1: //vgpr_d0
60698                 return 4;
60699               case 2: //vgpr_rtn
60700                 return 4;
60701               default:
60702                 fatal("op idx %i out of bounds\n", opIdx);
60703                 return -1;
60704             }
60705         } // getOperandSize
60706
60707         bool
60708         isSrcOperand(int opIdx) override
60709         {
60710             switch (opIdx) {
60711               case 0: //vgpr_a
60712                 return true;
60713               case 1: //vgpr_d0
60714                 return true;
60715               case 2: //vgpr_rtn
60716                 return false;
60717               default:
60718                 fatal("op idx %i out of bounds\n", opIdx);
60719                 return false;
60720             }
60721         } // isSrcOperand
60722
60723         bool
60724         isDstOperand(int opIdx) override
60725         {
60726             switch (opIdx) {
60727               case 0: //vgpr_a
60728                 return false;
60729               case 1: //vgpr_d0
60730                 return false;
60731               case 2: //vgpr_rtn
60732                 return true;
60733               default:
60734                 fatal("op idx %i out of bounds\n", opIdx);
60735                 return false;
60736             }
60737         } // isDstOperand
60738
60739         void execute(GPUDynInstPtr) override;
60740     }; // Inst_DS__DS_XOR_RTN_B32
60741
60742     class Inst_DS__DS_MSKOR_RTN_B32 : public Inst_DS
60743     {
60744       public:
60745         Inst_DS__DS_MSKOR_RTN_B32(InFmt_DS*);
60746         ~Inst_DS__DS_MSKOR_RTN_B32();
60747
60748         int
60749         getNumOperands() override
60750         {
60751             return numDstRegOperands() + numSrcRegOperands();
60752         } // getNumOperands
60753
60754         int numDstRegOperands() override { return 1; }
60755         int numSrcRegOperands() override { return 3; }
60756
60757         int
60758         getOperandSize(int opIdx) override
60759         {
60760             switch (opIdx) {
60761               case 0: //vgpr_a
60762                 return 4;
60763               case 1: //vgpr_d1
60764                 return 4;
60765               case 2: //vgpr_rtn
60766                 return 4;
60767               default:
60768                 fatal("op idx %i out of bounds\n", opIdx);
60769                 return -1;
60770             }
60771         } // getOperandSize
60772
60773         bool
60774         isSrcOperand(int opIdx) override
60775         {
60776             switch (opIdx) {
60777               case 0: //vgpr_a
60778                 return true;
60779               case 1: //vgpr_d1
60780                 return true;
60781               case 2: //vgpr_rtn
60782                 return false;
60783               default:
60784                 fatal("op idx %i out of bounds\n", opIdx);
60785                 return false;
60786             }
60787         } // isSrcOperand
60788
60789         bool
60790         isDstOperand(int opIdx) override
60791         {
60792             switch (opIdx) {
60793               case 0: //vgpr_a
60794                 return false;
60795               case 1: //vgpr_d1
60796                 return false;
60797               case 2: //vgpr_rtn
60798                 return true;
60799               default:
60800                 fatal("op idx %i out of bounds\n", opIdx);
60801                 return false;
60802             }
60803         } // isDstOperand
60804
60805         void execute(GPUDynInstPtr) override;
60806     }; // Inst_DS__DS_MSKOR_RTN_B32
60807
60808     class Inst_DS__DS_WRXCHG_RTN_B32 : public Inst_DS
60809     {
60810       public:
60811         Inst_DS__DS_WRXCHG_RTN_B32(InFmt_DS*);
60812         ~Inst_DS__DS_WRXCHG_RTN_B32();
60813
60814         int
60815         getNumOperands() override
60816         {
60817             return numDstRegOperands() + numSrcRegOperands();
60818         } // getNumOperands
60819
60820         int numDstRegOperands() override { return 1; }
60821         int numSrcRegOperands() override { return 2; }
60822
60823         int
60824         getOperandSize(int opIdx) override
60825         {
60826             switch (opIdx) {
60827               case 0: //vgpr_a
60828                 return 4;
60829               case 1: //vgpr_d0
60830                 return 4;
60831               case 2: //vgpr_rtn
60832                 return 4;
60833               default:
60834                 fatal("op idx %i out of bounds\n", opIdx);
60835                 return -1;
60836             }
60837         } // getOperandSize
60838
60839         bool
60840         isSrcOperand(int opIdx) override
60841         {
60842             switch (opIdx) {
60843               case 0: //vgpr_a
60844                 return true;
60845               case 1: //vgpr_d0
60846                 return true;
60847               case 2: //vgpr_rtn
60848                 return false;
60849               default:
60850                 fatal("op idx %i out of bounds\n", opIdx);
60851                 return false;
60852             }
60853         } // isSrcOperand
60854
60855         bool
60856         isDstOperand(int opIdx) override
60857         {
60858             switch (opIdx) {
60859               case 0: //vgpr_a
60860                 return false;
60861               case 1: //vgpr_d0
60862                 return false;
60863               case 2: //vgpr_rtn
60864                 return true;
60865               default:
60866                 fatal("op idx %i out of bounds\n", opIdx);
60867                 return false;
60868             }
60869         } // isDstOperand
60870
60871         void execute(GPUDynInstPtr) override;
60872     }; // Inst_DS__DS_WRXCHG_RTN_B32
60873
60874     class Inst_DS__DS_WRXCHG2_RTN_B32 : public Inst_DS
60875     {
60876       public:
60877         Inst_DS__DS_WRXCHG2_RTN_B32(InFmt_DS*);
60878         ~Inst_DS__DS_WRXCHG2_RTN_B32();
60879
60880         int
60881         getNumOperands() override
60882         {
60883             return numDstRegOperands() + numSrcRegOperands();
60884         } // getNumOperands
60885
60886         int numDstRegOperands() override { return 1; }
60887         int numSrcRegOperands() override { return 3; }
60888
60889         int
60890         getOperandSize(int opIdx) override
60891         {
60892             switch (opIdx) {
60893               case 0: //vgpr_a
60894                 return 4;
60895               case 1: //vgpr_d1
60896                 return 4;
60897               case 2: //vgpr_rtn
60898                 return 4;
60899               default:
60900                 fatal("op idx %i out of bounds\n", opIdx);
60901                 return -1;
60902             }
60903         } // getOperandSize
60904
60905         bool
60906         isSrcOperand(int opIdx) override
60907         {
60908             switch (opIdx) {
60909               case 0: //vgpr_a
60910                 return true;
60911               case 1: //vgpr_d1
60912                 return true;
60913               case 2: //vgpr_rtn
60914                 return false;
60915               default:
60916                 fatal("op idx %i out of bounds\n", opIdx);
60917                 return false;
60918             }
60919         } // isSrcOperand
60920
60921         bool
60922         isDstOperand(int opIdx) override
60923         {
60924             switch (opIdx) {
60925               case 0: //vgpr_a
60926                 return false;
60927               case 1: //vgpr_d1
60928                 return false;
60929               case 2: //vgpr_rtn
60930                 return true;
60931               default:
60932                 fatal("op idx %i out of bounds\n", opIdx);
60933                 return false;
60934             }
60935         } // isDstOperand
60936
60937         void execute(GPUDynInstPtr) override;
60938     }; // Inst_DS__DS_WRXCHG2_RTN_B32
60939
60940     class Inst_DS__DS_WRXCHG2ST64_RTN_B32 : public Inst_DS
60941     {
60942       public:
60943         Inst_DS__DS_WRXCHG2ST64_RTN_B32(InFmt_DS*);
60944         ~Inst_DS__DS_WRXCHG2ST64_RTN_B32();
60945
60946         int
60947         getNumOperands() override
60948         {
60949             return numDstRegOperands() + numSrcRegOperands();
60950         } // getNumOperands
60951
60952         int numDstRegOperands() override { return 1; }
60953         int numSrcRegOperands() override { return 3; }
60954
60955         int
60956         getOperandSize(int opIdx) override
60957         {
60958             switch (opIdx) {
60959               case 0: //vgpr_a
60960                 return 4;
60961               case 1: //vgpr_d1
60962                 return 4;
60963               case 2: //vgpr_rtn
60964                 return 4;
60965               default:
60966                 fatal("op idx %i out of bounds\n", opIdx);
60967                 return -1;
60968             }
60969         } // getOperandSize
60970
60971         bool
60972         isSrcOperand(int opIdx) override
60973         {
60974             switch (opIdx) {
60975               case 0: //vgpr_a
60976                 return true;
60977               case 1: //vgpr_d1
60978                 return true;
60979               case 2: //vgpr_rtn
60980                 return false;
60981               default:
60982                 fatal("op idx %i out of bounds\n", opIdx);
60983                 return false;
60984             }
60985         } // isSrcOperand
60986
60987         bool
60988         isDstOperand(int opIdx) override
60989         {
60990             switch (opIdx) {
60991               case 0: //vgpr_a
60992                 return false;
60993               case 1: //vgpr_d1
60994                 return false;
60995               case 2: //vgpr_rtn
60996                 return true;
60997               default:
60998                 fatal("op idx %i out of bounds\n", opIdx);
60999                 return false;
61000             }
61001         } // isDstOperand
61002
61003         void execute(GPUDynInstPtr) override;
61004     }; // Inst_DS__DS_WRXCHG2ST64_RTN_B32
61005
61006     class Inst_DS__DS_CMPST_RTN_B32 : public Inst_DS
61007     {
61008       public:
61009         Inst_DS__DS_CMPST_RTN_B32(InFmt_DS*);
61010         ~Inst_DS__DS_CMPST_RTN_B32();
61011
61012         int
61013         getNumOperands() override
61014         {
61015             return numDstRegOperands() + numSrcRegOperands();
61016         } // getNumOperands
61017
61018         int numDstRegOperands() override { return 1; }
61019         int numSrcRegOperands() override { return 3; }
61020
61021         int
61022         getOperandSize(int opIdx) override
61023         {
61024             switch (opIdx) {
61025               case 0: //vgpr_a
61026                 return 4;
61027               case 1: //vgpr_d1
61028                 return 4;
61029               case 2: //vgpr_rtn
61030                 return 4;
61031               default:
61032                 fatal("op idx %i out of bounds\n", opIdx);
61033                 return -1;
61034             }
61035         } // getOperandSize
61036
61037         bool
61038         isSrcOperand(int opIdx) override
61039         {
61040             switch (opIdx) {
61041               case 0: //vgpr_a
61042                 return true;
61043               case 1: //vgpr_d1
61044                 return true;
61045               case 2: //vgpr_rtn
61046                 return false;
61047               default:
61048                 fatal("op idx %i out of bounds\n", opIdx);
61049                 return false;
61050             }
61051         } // isSrcOperand
61052
61053         bool
61054         isDstOperand(int opIdx) override
61055         {
61056             switch (opIdx) {
61057               case 0: //vgpr_a
61058                 return false;
61059               case 1: //vgpr_d1
61060                 return false;
61061               case 2: //vgpr_rtn
61062                 return true;
61063               default:
61064                 fatal("op idx %i out of bounds\n", opIdx);
61065                 return false;
61066             }
61067         } // isDstOperand
61068
61069         void execute(GPUDynInstPtr) override;
61070     }; // Inst_DS__DS_CMPST_RTN_B32
61071
61072     class Inst_DS__DS_CMPST_RTN_F32 : public Inst_DS
61073     {
61074       public:
61075         Inst_DS__DS_CMPST_RTN_F32(InFmt_DS*);
61076         ~Inst_DS__DS_CMPST_RTN_F32();
61077
61078         int
61079         getNumOperands() override
61080         {
61081             return numDstRegOperands() + numSrcRegOperands();
61082         } // getNumOperands
61083
61084         int numDstRegOperands() override { return 1; }
61085         int numSrcRegOperands() override { return 3; }
61086
61087         int
61088         getOperandSize(int opIdx) override
61089         {
61090             switch (opIdx) {
61091               case 0: //vgpr_a
61092                 return 4;
61093               case 1: //vgpr_d1
61094                 return 4;
61095               case 2: //vgpr_rtn
61096                 return 4;
61097               default:
61098                 fatal("op idx %i out of bounds\n", opIdx);
61099                 return -1;
61100             }
61101         } // getOperandSize
61102
61103         bool
61104         isSrcOperand(int opIdx) override
61105         {
61106             switch (opIdx) {
61107               case 0: //vgpr_a
61108                 return true;
61109               case 1: //vgpr_d1
61110                 return true;
61111               case 2: //vgpr_rtn
61112                 return false;
61113               default:
61114                 fatal("op idx %i out of bounds\n", opIdx);
61115                 return false;
61116             }
61117         } // isSrcOperand
61118
61119         bool
61120         isDstOperand(int opIdx) override
61121         {
61122             switch (opIdx) {
61123               case 0: //vgpr_a
61124                 return false;
61125               case 1: //vgpr_d1
61126                 return false;
61127               case 2: //vgpr_rtn
61128                 return true;
61129               default:
61130                 fatal("op idx %i out of bounds\n", opIdx);
61131                 return false;
61132             }
61133         } // isDstOperand
61134
61135         void execute(GPUDynInstPtr) override;
61136     }; // Inst_DS__DS_CMPST_RTN_F32
61137
61138     class Inst_DS__DS_MIN_RTN_F32 : public Inst_DS
61139     {
61140       public:
61141         Inst_DS__DS_MIN_RTN_F32(InFmt_DS*);
61142         ~Inst_DS__DS_MIN_RTN_F32();
61143
61144         int
61145         getNumOperands() override
61146         {
61147             return numDstRegOperands() + numSrcRegOperands();
61148         } // getNumOperands
61149
61150         int numDstRegOperands() override { return 1; }
61151         int numSrcRegOperands() override { return 2; }
61152
61153         int
61154         getOperandSize(int opIdx) override
61155         {
61156             switch (opIdx) {
61157               case 0: //vgpr_a
61158                 return 4;
61159               case 1: //vgpr_d0
61160                 return 4;
61161               case 2: //vgpr_rtn
61162                 return 4;
61163               default:
61164                 fatal("op idx %i out of bounds\n", opIdx);
61165                 return -1;
61166             }
61167         } // getOperandSize
61168
61169         bool
61170         isSrcOperand(int opIdx) override
61171         {
61172             switch (opIdx) {
61173               case 0: //vgpr_a
61174                 return true;
61175               case 1: //vgpr_d0
61176                 return true;
61177               case 2: //vgpr_rtn
61178                 return false;
61179               default:
61180                 fatal("op idx %i out of bounds\n", opIdx);
61181                 return false;
61182             }
61183         } // isSrcOperand
61184
61185         bool
61186         isDstOperand(int opIdx) override
61187         {
61188             switch (opIdx) {
61189               case 0: //vgpr_a
61190                 return false;
61191               case 1: //vgpr_d0
61192                 return false;
61193               case 2: //vgpr_rtn
61194                 return true;
61195               default:
61196                 fatal("op idx %i out of bounds\n", opIdx);
61197                 return false;
61198             }
61199         } // isDstOperand
61200
61201         void execute(GPUDynInstPtr) override;
61202     }; // Inst_DS__DS_MIN_RTN_F32
61203
61204     class Inst_DS__DS_MAX_RTN_F32 : public Inst_DS
61205     {
61206       public:
61207         Inst_DS__DS_MAX_RTN_F32(InFmt_DS*);
61208         ~Inst_DS__DS_MAX_RTN_F32();
61209
61210         int
61211         getNumOperands() override
61212         {
61213             return numDstRegOperands() + numSrcRegOperands();
61214         } // getNumOperands
61215
61216         int numDstRegOperands() override { return 1; }
61217         int numSrcRegOperands() override { return 2; }
61218
61219         int
61220         getOperandSize(int opIdx) override
61221         {
61222             switch (opIdx) {
61223               case 0: //vgpr_a
61224                 return 4;
61225               case 1: //vgpr_d0
61226                 return 4;
61227               case 2: //vgpr_rtn
61228                 return 4;
61229               default:
61230                 fatal("op idx %i out of bounds\n", opIdx);
61231                 return -1;
61232             }
61233         } // getOperandSize
61234
61235         bool
61236         isSrcOperand(int opIdx) override
61237         {
61238             switch (opIdx) {
61239               case 0: //vgpr_a
61240                 return true;
61241               case 1: //vgpr_d0
61242                 return true;
61243               case 2: //vgpr_rtn
61244                 return false;
61245               default:
61246                 fatal("op idx %i out of bounds\n", opIdx);
61247                 return false;
61248             }
61249         } // isSrcOperand
61250
61251         bool
61252         isDstOperand(int opIdx) override
61253         {
61254             switch (opIdx) {
61255               case 0: //vgpr_a
61256                 return false;
61257               case 1: //vgpr_d0
61258                 return false;
61259               case 2: //vgpr_rtn
61260                 return true;
61261               default:
61262                 fatal("op idx %i out of bounds\n", opIdx);
61263                 return false;
61264             }
61265         } // isDstOperand
61266
61267         void execute(GPUDynInstPtr) override;
61268     }; // Inst_DS__DS_MAX_RTN_F32
61269
61270     class Inst_DS__DS_WRAP_RTN_B32 : public Inst_DS
61271     {
61272       public:
61273         Inst_DS__DS_WRAP_RTN_B32(InFmt_DS*);
61274         ~Inst_DS__DS_WRAP_RTN_B32();
61275
61276         int
61277         getNumOperands() override
61278         {
61279             return numDstRegOperands() + numSrcRegOperands();
61280         } // getNumOperands
61281
61282         int numDstRegOperands() override { return 1; }
61283         int numSrcRegOperands() override { return 3; }
61284
61285         int
61286         getOperandSize(int opIdx) override
61287         {
61288             switch (opIdx) {
61289               case 0: //vgpr_a
61290                 return 4;
61291               case 1: //vgpr_d1
61292                 return 4;
61293               case 2: //vgpr_rtn
61294                 return 4;
61295               default:
61296                 fatal("op idx %i out of bounds\n", opIdx);
61297                 return -1;
61298             }
61299         } // getOperandSize
61300
61301         bool
61302         isSrcOperand(int opIdx) override
61303         {
61304             switch (opIdx) {
61305               case 0: //vgpr_a
61306                 return true;
61307               case 1: //vgpr_d1
61308                 return true;
61309               case 2: //vgpr_rtn
61310                 return false;
61311               default:
61312                 fatal("op idx %i out of bounds\n", opIdx);
61313                 return false;
61314             }
61315         } // isSrcOperand
61316
61317         bool
61318         isDstOperand(int opIdx) override
61319         {
61320             switch (opIdx) {
61321               case 0: //vgpr_a
61322                 return false;
61323               case 1: //vgpr_d1
61324                 return false;
61325               case 2: //vgpr_rtn
61326                 return true;
61327               default:
61328                 fatal("op idx %i out of bounds\n", opIdx);
61329                 return false;
61330             }
61331         } // isDstOperand
61332
61333         void execute(GPUDynInstPtr) override;
61334     }; // Inst_DS__DS_WRAP_RTN_B32
61335
61336     class Inst_DS__DS_ADD_RTN_F32 : public Inst_DS
61337     {
61338       public:
61339         Inst_DS__DS_ADD_RTN_F32(InFmt_DS*);
61340         ~Inst_DS__DS_ADD_RTN_F32();
61341
61342         int
61343         getNumOperands() override
61344         {
61345             return numDstRegOperands() + numSrcRegOperands();
61346         } // getNumOperands
61347
61348         int numDstRegOperands() override { return 1; }
61349         int numSrcRegOperands() override { return 2; }
61350
61351         int
61352         getOperandSize(int opIdx) override
61353         {
61354             switch (opIdx) {
61355               case 0: //vgpr_a
61356                 return 4;
61357               case 1: //vgpr_d0
61358                 return 4;
61359               case 2: //vgpr_rtn
61360                 return 4;
61361               default:
61362                 fatal("op idx %i out of bounds\n", opIdx);
61363                 return -1;
61364             }
61365         } // getOperandSize
61366
61367         bool
61368         isSrcOperand(int opIdx) override
61369         {
61370             switch (opIdx) {
61371               case 0: //vgpr_a
61372                 return true;
61373               case 1: //vgpr_d0
61374                 return true;
61375               case 2: //vgpr_rtn
61376                 return false;
61377               default:
61378                 fatal("op idx %i out of bounds\n", opIdx);
61379                 return false;
61380             }
61381         } // isSrcOperand
61382
61383         bool
61384         isDstOperand(int opIdx) override
61385         {
61386             switch (opIdx) {
61387               case 0: //vgpr_a
61388                 return false;
61389               case 1: //vgpr_d0
61390                 return false;
61391               case 2: //vgpr_rtn
61392                 return true;
61393               default:
61394                 fatal("op idx %i out of bounds\n", opIdx);
61395                 return false;
61396             }
61397         } // isDstOperand
61398
61399         void execute(GPUDynInstPtr) override;
61400     }; // Inst_DS__DS_ADD_RTN_F32
61401
61402     class Inst_DS__DS_READ_B32 : public Inst_DS
61403     {
61404       public:
61405         Inst_DS__DS_READ_B32(InFmt_DS*);
61406         ~Inst_DS__DS_READ_B32();
61407
61408         int
61409         getNumOperands() override
61410         {
61411             return numDstRegOperands() + numSrcRegOperands();
61412         } // getNumOperands
61413
61414         int numDstRegOperands() override { return 1; }
61415         int numSrcRegOperands() override { return 1; }
61416
61417         int
61418         getOperandSize(int opIdx) override
61419         {
61420             switch (opIdx) {
61421               case 0: //vgpr_a
61422                 return 4;
61423               case 1: //vgpr_rtn
61424                 return 4;
61425               default:
61426                 fatal("op idx %i out of bounds\n", opIdx);
61427                 return -1;
61428             }
61429         } // getOperandSize
61430
61431         bool
61432         isSrcOperand(int opIdx) override
61433         {
61434             switch (opIdx) {
61435               case 0: //vgpr_a
61436                 return true;
61437               case 1: //vgpr_rtn
61438                 return false;
61439               default:
61440                 fatal("op idx %i out of bounds\n", opIdx);
61441                 return false;
61442             }
61443         } // isSrcOperand
61444
61445         bool
61446         isDstOperand(int opIdx) override
61447         {
61448             switch (opIdx) {
61449               case 0: //vgpr_a
61450                 return false;
61451               case 1: //vgpr_rtn
61452                 return true;
61453               default:
61454                 fatal("op idx %i out of bounds\n", opIdx);
61455                 return false;
61456             }
61457         } // isDstOperand
61458
61459         void execute(GPUDynInstPtr) override;
61460         void initiateAcc(GPUDynInstPtr) override;
61461         void completeAcc(GPUDynInstPtr) override;
61462     }; // Inst_DS__DS_READ_B32
61463
61464     class Inst_DS__DS_READ2_B32 : public Inst_DS
61465     {
61466       public:
61467         Inst_DS__DS_READ2_B32(InFmt_DS*);
61468         ~Inst_DS__DS_READ2_B32();
61469
61470         int
61471         getNumOperands() override
61472         {
61473             return numDstRegOperands() + numSrcRegOperands();
61474         } // getNumOperands
61475
61476         int numDstRegOperands() override { return 1; }
61477         int numSrcRegOperands() override { return 1; }
61478
61479         int
61480         getOperandSize(int opIdx) override
61481         {
61482             switch (opIdx) {
61483               case 0: //vgpr_a
61484                 return 4;
61485               case 1: //vgpr_rtn
61486                 return 8;
61487               default:
61488                 fatal("op idx %i out of bounds\n", opIdx);
61489                 return -1;
61490             }
61491         } // getOperandSize
61492
61493         bool
61494         isSrcOperand(int opIdx) override
61495         {
61496             switch (opIdx) {
61497               case 0: //vgpr_a
61498                 return true;
61499               case 1: //vgpr_rtn
61500                 return false;
61501               default:
61502                 fatal("op idx %i out of bounds\n", opIdx);
61503                 return false;
61504             }
61505         } // isSrcOperand
61506
61507         bool
61508         isDstOperand(int opIdx) override
61509         {
61510             switch (opIdx) {
61511               case 0: //vgpr_a
61512                 return false;
61513               case 1: //vgpr_rtn
61514                 return true;
61515               default:
61516                 fatal("op idx %i out of bounds\n", opIdx);
61517                 return false;
61518             }
61519         } // isDstOperand
61520
61521         void execute(GPUDynInstPtr) override;
61522         void initiateAcc(GPUDynInstPtr) override;
61523         void completeAcc(GPUDynInstPtr) override;
61524     }; // Inst_DS__DS_READ2_B32
61525
61526     class Inst_DS__DS_READ2ST64_B32 : public Inst_DS
61527     {
61528       public:
61529         Inst_DS__DS_READ2ST64_B32(InFmt_DS*);
61530         ~Inst_DS__DS_READ2ST64_B32();
61531
61532         int
61533         getNumOperands() override
61534         {
61535             return numDstRegOperands() + numSrcRegOperands();
61536         } // getNumOperands
61537
61538         int numDstRegOperands() override { return 1; }
61539         int numSrcRegOperands() override { return 1; }
61540
61541         int
61542         getOperandSize(int opIdx) override
61543         {
61544             switch (opIdx) {
61545               case 0: //vgpr_a
61546                 return 4;
61547               case 1: //vgpr_rtn
61548                 return 4;
61549               default:
61550                 fatal("op idx %i out of bounds\n", opIdx);
61551                 return -1;
61552             }
61553         } // getOperandSize
61554
61555         bool
61556         isSrcOperand(int opIdx) override
61557         {
61558             switch (opIdx) {
61559               case 0: //vgpr_a
61560                 return true;
61561               case 1: //vgpr_rtn
61562                 return false;
61563               default:
61564                 fatal("op idx %i out of bounds\n", opIdx);
61565                 return false;
61566             }
61567         } // isSrcOperand
61568
61569         bool
61570         isDstOperand(int opIdx) override
61571         {
61572             switch (opIdx) {
61573               case 0: //vgpr_a
61574                 return false;
61575               case 1: //vgpr_rtn
61576                 return true;
61577               default:
61578                 fatal("op idx %i out of bounds\n", opIdx);
61579                 return false;
61580             }
61581         } // isDstOperand
61582
61583         void execute(GPUDynInstPtr) override;
61584         void initiateAcc(GPUDynInstPtr) override;
61585         void completeAcc(GPUDynInstPtr) override;
61586     }; // Inst_DS__DS_READ2ST64_B32
61587
61588     class Inst_DS__DS_READ_I8 : public Inst_DS
61589     {
61590       public:
61591         Inst_DS__DS_READ_I8(InFmt_DS*);
61592         ~Inst_DS__DS_READ_I8();
61593
61594         int
61595         getNumOperands() override
61596         {
61597             return numDstRegOperands() + numSrcRegOperands();
61598         } // getNumOperands
61599
61600         int numDstRegOperands() override { return 1; }
61601         int numSrcRegOperands() override { return 1; }
61602
61603         int
61604         getOperandSize(int opIdx) override
61605         {
61606             switch (opIdx) {
61607               case 0: //vgpr_a
61608                 return 4;
61609               case 1: //vgpr_rtn
61610                 return 1;
61611               default:
61612                 fatal("op idx %i out of bounds\n", opIdx);
61613                 return -1;
61614             }
61615         } // getOperandSize
61616
61617         bool
61618         isSrcOperand(int opIdx) override
61619         {
61620             switch (opIdx) {
61621               case 0: //vgpr_a
61622                 return true;
61623               case 1: //vgpr_rtn
61624                 return false;
61625               default:
61626                 fatal("op idx %i out of bounds\n", opIdx);
61627                 return false;
61628             }
61629         } // isSrcOperand
61630
61631         bool
61632         isDstOperand(int opIdx) override
61633         {
61634             switch (opIdx) {
61635               case 0: //vgpr_a
61636                 return false;
61637               case 1: //vgpr_rtn
61638                 return true;
61639               default:
61640                 fatal("op idx %i out of bounds\n", opIdx);
61641                 return false;
61642             }
61643         } // isDstOperand
61644
61645         void execute(GPUDynInstPtr) override;
61646     }; // Inst_DS__DS_READ_I8
61647
61648     class Inst_DS__DS_READ_U8 : public Inst_DS
61649     {
61650       public:
61651         Inst_DS__DS_READ_U8(InFmt_DS*);
61652         ~Inst_DS__DS_READ_U8();
61653
61654         int
61655         getNumOperands() override
61656         {
61657             return numDstRegOperands() + numSrcRegOperands();
61658         } // getNumOperands
61659
61660         int numDstRegOperands() override { return 1; }
61661         int numSrcRegOperands() override { return 1; }
61662
61663         int
61664         getOperandSize(int opIdx) override
61665         {
61666             switch (opIdx) {
61667               case 0: //vgpr_a
61668                 return 4;
61669               case 1: //vgpr_rtn
61670                 return 1;
61671               default:
61672                 fatal("op idx %i out of bounds\n", opIdx);
61673                 return -1;
61674             }
61675         } // getOperandSize
61676
61677         bool
61678         isSrcOperand(int opIdx) override
61679         {
61680             switch (opIdx) {
61681               case 0: //vgpr_a
61682                 return true;
61683               case 1: //vgpr_rtn
61684                 return false;
61685               default:
61686                 fatal("op idx %i out of bounds\n", opIdx);
61687                 return false;
61688             }
61689         } // isSrcOperand
61690
61691         bool
61692         isDstOperand(int opIdx) override
61693         {
61694             switch (opIdx) {
61695               case 0: //vgpr_a
61696                 return false;
61697               case 1: //vgpr_rtn
61698                 return true;
61699               default:
61700                 fatal("op idx %i out of bounds\n", opIdx);
61701                 return false;
61702             }
61703         } // isDstOperand
61704
61705         void execute(GPUDynInstPtr) override;
61706         void initiateAcc(GPUDynInstPtr) override;
61707         void completeAcc(GPUDynInstPtr) override;
61708     }; // Inst_DS__DS_READ_U8
61709
61710     class Inst_DS__DS_READ_I16 : public Inst_DS
61711     {
61712       public:
61713         Inst_DS__DS_READ_I16(InFmt_DS*);
61714         ~Inst_DS__DS_READ_I16();
61715
61716         int
61717         getNumOperands() override
61718         {
61719             return numDstRegOperands() + numSrcRegOperands();
61720         } // getNumOperands
61721
61722         int numDstRegOperands() override { return 1; }
61723         int numSrcRegOperands() override { return 1; }
61724
61725         int
61726         getOperandSize(int opIdx) override
61727         {
61728             switch (opIdx) {
61729               case 0: //vgpr_a
61730                 return 4;
61731               case 1: //vgpr_rtn
61732                 return 2;
61733               default:
61734                 fatal("op idx %i out of bounds\n", opIdx);
61735                 return -1;
61736             }
61737         } // getOperandSize
61738
61739         bool
61740         isSrcOperand(int opIdx) override
61741         {
61742             switch (opIdx) {
61743               case 0: //vgpr_a
61744                 return true;
61745               case 1: //vgpr_rtn
61746                 return false;
61747               default:
61748                 fatal("op idx %i out of bounds\n", opIdx);
61749                 return false;
61750             }
61751         } // isSrcOperand
61752
61753         bool
61754         isDstOperand(int opIdx) override
61755         {
61756             switch (opIdx) {
61757               case 0: //vgpr_a
61758                 return false;
61759               case 1: //vgpr_rtn
61760                 return true;
61761               default:
61762                 fatal("op idx %i out of bounds\n", opIdx);
61763                 return false;
61764             }
61765         } // isDstOperand
61766
61767         void execute(GPUDynInstPtr) override;
61768     }; // Inst_DS__DS_READ_I16
61769
61770     class Inst_DS__DS_READ_U16 : public Inst_DS
61771     {
61772       public:
61773         Inst_DS__DS_READ_U16(InFmt_DS*);
61774         ~Inst_DS__DS_READ_U16();
61775
61776         int
61777         getNumOperands() override
61778         {
61779             return numDstRegOperands() + numSrcRegOperands();
61780         } // getNumOperands
61781
61782         int numDstRegOperands() override { return 1; }
61783         int numSrcRegOperands() override { return 1; }
61784
61785         int
61786         getOperandSize(int opIdx) override
61787         {
61788             switch (opIdx) {
61789               case 0: //vgpr_a
61790                 return 4;
61791               case 1: //vgpr_rtn
61792                 return 2;
61793               default:
61794                 fatal("op idx %i out of bounds\n", opIdx);
61795                 return -1;
61796             }
61797         } // getOperandSize
61798
61799         bool
61800         isSrcOperand(int opIdx) override
61801         {
61802             switch (opIdx) {
61803               case 0: //vgpr_a
61804                 return true;
61805               case 1: //vgpr_rtn
61806                 return false;
61807               default:
61808                 fatal("op idx %i out of bounds\n", opIdx);
61809                 return false;
61810             }
61811         } // isSrcOperand
61812
61813         bool
61814         isDstOperand(int opIdx) override
61815         {
61816             switch (opIdx) {
61817               case 0: //vgpr_a
61818                 return false;
61819               case 1: //vgpr_rtn
61820                 return true;
61821               default:
61822                 fatal("op idx %i out of bounds\n", opIdx);
61823                 return false;
61824             }
61825         } // isDstOperand
61826
61827         void execute(GPUDynInstPtr) override;
61828         void initiateAcc(GPUDynInstPtr) override;
61829         void completeAcc(GPUDynInstPtr) override;
61830     }; // Inst_DS__DS_READ_U16
61831
61832     class Inst_DS__DS_SWIZZLE_B32 : public Inst_DS
61833     {
61834       public:
61835         Inst_DS__DS_SWIZZLE_B32(InFmt_DS*);
61836         ~Inst_DS__DS_SWIZZLE_B32();
61837
61838         int
61839         getNumOperands() override
61840         {
61841             return numDstRegOperands() + numSrcRegOperands();
61842         } // getNumOperands
61843
61844         int numDstRegOperands() override { return 1; }
61845         int numSrcRegOperands() override { return 1; }
61846
61847         int
61848         getOperandSize(int opIdx) override
61849         {
61850             switch (opIdx) {
61851               case 0: //vgpr_a
61852                 return 4;
61853               case 1: //vgpr_rtn
61854                 return 4;
61855               default:
61856                 fatal("op idx %i out of bounds\n", opIdx);
61857                 return -1;
61858             }
61859         } // getOperandSize
61860
61861         bool
61862         isSrcOperand(int opIdx) override
61863         {
61864             switch (opIdx) {
61865               case 0: //vgpr_a
61866                 return true;
61867               case 1: //vgpr_rtn
61868                 return false;
61869               default:
61870                 fatal("op idx %i out of bounds\n", opIdx);
61871                 return false;
61872             }
61873         } // isSrcOperand
61874
61875         bool
61876         isDstOperand(int opIdx) override
61877         {
61878             switch (opIdx) {
61879               case 0: //vgpr_a
61880                 return false;
61881               case 1: //vgpr_rtn
61882                 return true;
61883               default:
61884                 fatal("op idx %i out of bounds\n", opIdx);
61885                 return false;
61886             }
61887         } // isDstOperand
61888
61889         void execute(GPUDynInstPtr) override;
61890     }; // Inst_DS__DS_SWIZZLE_B32
61891
61892     class Inst_DS__DS_PERMUTE_B32 : public Inst_DS
61893     {
61894       public:
61895         Inst_DS__DS_PERMUTE_B32(InFmt_DS*);
61896         ~Inst_DS__DS_PERMUTE_B32();
61897
61898         int
61899         getNumOperands() override
61900         {
61901             return numDstRegOperands() + numSrcRegOperands();
61902         } // getNumOperands
61903
61904         int numDstRegOperands() override { return 1; }
61905         int numSrcRegOperands() override { return 2; }
61906
61907         int
61908         getOperandSize(int opIdx) override
61909         {
61910             switch (opIdx) {
61911               case 0: //vgpr_a
61912                 return 4;
61913               case 1: //vgpr_d0
61914                 return 4;
61915               case 2: //vgpr_rtn
61916                 return 4;
61917               default:
61918                 fatal("op idx %i out of bounds\n", opIdx);
61919                 return -1;
61920             }
61921         } // getOperandSize
61922
61923         bool
61924         isSrcOperand(int opIdx) override
61925         {
61926             switch (opIdx) {
61927               case 0: //vgpr_a
61928                 return true;
61929               case 1: //vgpr_d0
61930                 return true;
61931               case 2: //vgpr_rtn
61932                 return false;
61933               default:
61934                 fatal("op idx %i out of bounds\n", opIdx);
61935                 return false;
61936             }
61937         } // isSrcOperand
61938
61939         bool
61940         isDstOperand(int opIdx) override
61941         {
61942             switch (opIdx) {
61943               case 0: //vgpr_a
61944                 return false;
61945               case 1: //vgpr_d0
61946                 return false;
61947               case 2: //vgpr_rtn
61948                 return true;
61949               default:
61950                 fatal("op idx %i out of bounds\n", opIdx);
61951                 return false;
61952             }
61953         } // isDstOperand
61954
61955         void execute(GPUDynInstPtr) override;
61956     }; // Inst_DS__DS_PERMUTE_B32
61957
61958     class Inst_DS__DS_BPERMUTE_B32 : public Inst_DS
61959     {
61960       public:
61961         Inst_DS__DS_BPERMUTE_B32(InFmt_DS*);
61962         ~Inst_DS__DS_BPERMUTE_B32();
61963
61964         int
61965         getNumOperands() override
61966         {
61967             return numDstRegOperands() + numSrcRegOperands();
61968         } // getNumOperands
61969
61970         int numDstRegOperands() override { return 1; }
61971         int numSrcRegOperands() override { return 2; }
61972
61973         int
61974         getOperandSize(int opIdx) override
61975         {
61976             switch (opIdx) {
61977               case 0: //vgpr_a
61978                 return 4;
61979               case 1: //vgpr_d0
61980                 return 4;
61981               case 2: //vgpr_rtn
61982                 return 4;
61983               default:
61984                 fatal("op idx %i out of bounds\n", opIdx);
61985                 return -1;
61986             }
61987         } // getOperandSize
61988
61989         bool
61990         isSrcOperand(int opIdx) override
61991         {
61992             switch (opIdx) {
61993               case 0: //vgpr_a
61994                 return true;
61995               case 1: //vgpr_d0
61996                 return true;
61997               case 2: //vgpr_rtn
61998                 return false;
61999               default:
62000                 fatal("op idx %i out of bounds\n", opIdx);
62001                 return false;
62002             }
62003         } // isSrcOperand
62004
62005         bool
62006         isDstOperand(int opIdx) override
62007         {
62008             switch (opIdx) {
62009               case 0: //vgpr_a
62010                 return false;
62011               case 1: //vgpr_d0
62012                 return false;
62013               case 2: //vgpr_rtn
62014                 return true;
62015               default:
62016                 fatal("op idx %i out of bounds\n", opIdx);
62017                 return false;
62018             }
62019         } // isDstOperand
62020
62021         void execute(GPUDynInstPtr) override;
62022     }; // Inst_DS__DS_BPERMUTE_B32
62023
62024     class Inst_DS__DS_ADD_U64 : public Inst_DS
62025     {
62026       public:
62027         Inst_DS__DS_ADD_U64(InFmt_DS*);
62028         ~Inst_DS__DS_ADD_U64();
62029
62030         int
62031         getNumOperands() override
62032         {
62033             return numDstRegOperands() + numSrcRegOperands();
62034         } // getNumOperands
62035
62036         int numDstRegOperands() override { return 0; }
62037         int numSrcRegOperands() override { return 2; }
62038
62039         int
62040         getOperandSize(int opIdx) override
62041         {
62042             switch (opIdx) {
62043               case 0: //vgpr_a
62044                 return 4;
62045               case 1: //vgpr_d0
62046                 return 8;
62047               default:
62048                 fatal("op idx %i out of bounds\n", opIdx);
62049                 return -1;
62050             }
62051         } // getOperandSize
62052
62053         bool
62054         isSrcOperand(int opIdx) override
62055         {
62056             switch (opIdx) {
62057               case 0: //vgpr_a
62058                 return true;
62059               case 1: //vgpr_d0
62060                 return true;
62061               default:
62062                 fatal("op idx %i out of bounds\n", opIdx);
62063                 return false;
62064             }
62065         } // isSrcOperand
62066
62067         bool
62068         isDstOperand(int opIdx) override
62069         {
62070             switch (opIdx) {
62071               case 0: //vgpr_a
62072                 return false;
62073               case 1: //vgpr_d0
62074                 return false;
62075               default:
62076                 fatal("op idx %i out of bounds\n", opIdx);
62077                 return false;
62078             }
62079         } // isDstOperand
62080
62081         void execute(GPUDynInstPtr) override;
62082     }; // Inst_DS__DS_ADD_U64
62083
62084     class Inst_DS__DS_SUB_U64 : public Inst_DS
62085     {
62086       public:
62087         Inst_DS__DS_SUB_U64(InFmt_DS*);
62088         ~Inst_DS__DS_SUB_U64();
62089
62090         int
62091         getNumOperands() override
62092         {
62093             return numDstRegOperands() + numSrcRegOperands();
62094         } // getNumOperands
62095
62096         int numDstRegOperands() override { return 0; }
62097         int numSrcRegOperands() override { return 2; }
62098
62099         int
62100         getOperandSize(int opIdx) override
62101         {
62102             switch (opIdx) {
62103               case 0: //vgpr_a
62104                 return 4;
62105               case 1: //vgpr_d0
62106                 return 8;
62107               default:
62108                 fatal("op idx %i out of bounds\n", opIdx);
62109                 return -1;
62110             }
62111         } // getOperandSize
62112
62113         bool
62114         isSrcOperand(int opIdx) override
62115         {
62116             switch (opIdx) {
62117               case 0: //vgpr_a
62118                 return true;
62119               case 1: //vgpr_d0
62120                 return true;
62121               default:
62122                 fatal("op idx %i out of bounds\n", opIdx);
62123                 return false;
62124             }
62125         } // isSrcOperand
62126
62127         bool
62128         isDstOperand(int opIdx) override
62129         {
62130             switch (opIdx) {
62131               case 0: //vgpr_a
62132                 return false;
62133               case 1: //vgpr_d0
62134                 return false;
62135               default:
62136                 fatal("op idx %i out of bounds\n", opIdx);
62137                 return false;
62138             }
62139         } // isDstOperand
62140
62141         void execute(GPUDynInstPtr) override;
62142     }; // Inst_DS__DS_SUB_U64
62143
62144     class Inst_DS__DS_RSUB_U64 : public Inst_DS
62145     {
62146       public:
62147         Inst_DS__DS_RSUB_U64(InFmt_DS*);
62148         ~Inst_DS__DS_RSUB_U64();
62149
62150         int
62151         getNumOperands() override
62152         {
62153             return numDstRegOperands() + numSrcRegOperands();
62154         } // getNumOperands
62155
62156         int numDstRegOperands() override { return 0; }
62157         int numSrcRegOperands() override { return 2; }
62158
62159         int
62160         getOperandSize(int opIdx) override
62161         {
62162             switch (opIdx) {
62163               case 0: //vgpr_a
62164                 return 4;
62165               case 1: //vgpr_d0
62166                 return 8;
62167               default:
62168                 fatal("op idx %i out of bounds\n", opIdx);
62169                 return -1;
62170             }
62171         } // getOperandSize
62172
62173         bool
62174         isSrcOperand(int opIdx) override
62175         {
62176             switch (opIdx) {
62177               case 0: //vgpr_a
62178                 return true;
62179               case 1: //vgpr_d0
62180                 return true;
62181               default:
62182                 fatal("op idx %i out of bounds\n", opIdx);
62183                 return false;
62184             }
62185         } // isSrcOperand
62186
62187         bool
62188         isDstOperand(int opIdx) override
62189         {
62190             switch (opIdx) {
62191               case 0: //vgpr_a
62192                 return false;
62193               case 1: //vgpr_d0
62194                 return false;
62195               default:
62196                 fatal("op idx %i out of bounds\n", opIdx);
62197                 return false;
62198             }
62199         } // isDstOperand
62200
62201         void execute(GPUDynInstPtr) override;
62202     }; // Inst_DS__DS_RSUB_U64
62203
62204     class Inst_DS__DS_INC_U64 : public Inst_DS
62205     {
62206       public:
62207         Inst_DS__DS_INC_U64(InFmt_DS*);
62208         ~Inst_DS__DS_INC_U64();
62209
62210         int
62211         getNumOperands() override
62212         {
62213             return numDstRegOperands() + numSrcRegOperands();
62214         } // getNumOperands
62215
62216         int numDstRegOperands() override { return 0; }
62217         int numSrcRegOperands() override { return 2; }
62218
62219         int
62220         getOperandSize(int opIdx) override
62221         {
62222             switch (opIdx) {
62223               case 0: //vgpr_a
62224                 return 4;
62225               case 1: //vgpr_d0
62226                 return 8;
62227               default:
62228                 fatal("op idx %i out of bounds\n", opIdx);
62229                 return -1;
62230             }
62231         } // getOperandSize
62232
62233         bool
62234         isSrcOperand(int opIdx) override
62235         {
62236             switch (opIdx) {
62237               case 0: //vgpr_a
62238                 return true;
62239               case 1: //vgpr_d0
62240                 return true;
62241               default:
62242                 fatal("op idx %i out of bounds\n", opIdx);
62243                 return false;
62244             }
62245         } // isSrcOperand
62246
62247         bool
62248         isDstOperand(int opIdx) override
62249         {
62250             switch (opIdx) {
62251               case 0: //vgpr_a
62252                 return false;
62253               case 1: //vgpr_d0
62254                 return false;
62255               default:
62256                 fatal("op idx %i out of bounds\n", opIdx);
62257                 return false;
62258             }
62259         } // isDstOperand
62260
62261         void execute(GPUDynInstPtr) override;
62262     }; // Inst_DS__DS_INC_U64
62263
62264     class Inst_DS__DS_DEC_U64 : public Inst_DS
62265     {
62266       public:
62267         Inst_DS__DS_DEC_U64(InFmt_DS*);
62268         ~Inst_DS__DS_DEC_U64();
62269
62270         int
62271         getNumOperands() override
62272         {
62273             return numDstRegOperands() + numSrcRegOperands();
62274         } // getNumOperands
62275
62276         int numDstRegOperands() override { return 0; }
62277         int numSrcRegOperands() override { return 2; }
62278
62279         int
62280         getOperandSize(int opIdx) override
62281         {
62282             switch (opIdx) {
62283               case 0: //vgpr_a
62284                 return 4;
62285               case 1: //vgpr_d0
62286                 return 8;
62287               default:
62288                 fatal("op idx %i out of bounds\n", opIdx);
62289                 return -1;
62290             }
62291         } // getOperandSize
62292
62293         bool
62294         isSrcOperand(int opIdx) override
62295         {
62296             switch (opIdx) {
62297               case 0: //vgpr_a
62298                 return true;
62299               case 1: //vgpr_d0
62300                 return true;
62301               default:
62302                 fatal("op idx %i out of bounds\n", opIdx);
62303                 return false;
62304             }
62305         } // isSrcOperand
62306
62307         bool
62308         isDstOperand(int opIdx) override
62309         {
62310             switch (opIdx) {
62311               case 0: //vgpr_a
62312                 return false;
62313               case 1: //vgpr_d0
62314                 return false;
62315               default:
62316                 fatal("op idx %i out of bounds\n", opIdx);
62317                 return false;
62318             }
62319         } // isDstOperand
62320
62321         void execute(GPUDynInstPtr) override;
62322     }; // Inst_DS__DS_DEC_U64
62323
62324     class Inst_DS__DS_MIN_I64 : public Inst_DS
62325     {
62326       public:
62327         Inst_DS__DS_MIN_I64(InFmt_DS*);
62328         ~Inst_DS__DS_MIN_I64();
62329
62330         int
62331         getNumOperands() override
62332         {
62333             return numDstRegOperands() + numSrcRegOperands();
62334         } // getNumOperands
62335
62336         int numDstRegOperands() override { return 0; }
62337         int numSrcRegOperands() override { return 2; }
62338
62339         int
62340         getOperandSize(int opIdx) override
62341         {
62342             switch (opIdx) {
62343               case 0: //vgpr_a
62344                 return 4;
62345               case 1: //vgpr_d0
62346                 return 8;
62347               default:
62348                 fatal("op idx %i out of bounds\n", opIdx);
62349                 return -1;
62350             }
62351         } // getOperandSize
62352
62353         bool
62354         isSrcOperand(int opIdx) override
62355         {
62356             switch (opIdx) {
62357               case 0: //vgpr_a
62358                 return true;
62359               case 1: //vgpr_d0
62360                 return true;
62361               default:
62362                 fatal("op idx %i out of bounds\n", opIdx);
62363                 return false;
62364             }
62365         } // isSrcOperand
62366
62367         bool
62368         isDstOperand(int opIdx) override
62369         {
62370             switch (opIdx) {
62371               case 0: //vgpr_a
62372                 return false;
62373               case 1: //vgpr_d0
62374                 return false;
62375               default:
62376                 fatal("op idx %i out of bounds\n", opIdx);
62377                 return false;
62378             }
62379         } // isDstOperand
62380
62381         void execute(GPUDynInstPtr) override;
62382     }; // Inst_DS__DS_MIN_I64
62383
62384     class Inst_DS__DS_MAX_I64 : public Inst_DS
62385     {
62386       public:
62387         Inst_DS__DS_MAX_I64(InFmt_DS*);
62388         ~Inst_DS__DS_MAX_I64();
62389
62390         int
62391         getNumOperands() override
62392         {
62393             return numDstRegOperands() + numSrcRegOperands();
62394         } // getNumOperands
62395
62396         int numDstRegOperands() override { return 0; }
62397         int numSrcRegOperands() override { return 2; }
62398
62399         int
62400         getOperandSize(int opIdx) override
62401         {
62402             switch (opIdx) {
62403               case 0: //vgpr_a
62404                 return 4;
62405               case 1: //vgpr_d0
62406                 return 8;
62407               default:
62408                 fatal("op idx %i out of bounds\n", opIdx);
62409                 return -1;
62410             }
62411         } // getOperandSize
62412
62413         bool
62414         isSrcOperand(int opIdx) override
62415         {
62416             switch (opIdx) {
62417               case 0: //vgpr_a
62418                 return true;
62419               case 1: //vgpr_d0
62420                 return true;
62421               default:
62422                 fatal("op idx %i out of bounds\n", opIdx);
62423                 return false;
62424             }
62425         } // isSrcOperand
62426
62427         bool
62428         isDstOperand(int opIdx) override
62429         {
62430             switch (opIdx) {
62431               case 0: //vgpr_a
62432                 return false;
62433               case 1: //vgpr_d0
62434                 return false;
62435               default:
62436                 fatal("op idx %i out of bounds\n", opIdx);
62437                 return false;
62438             }
62439         } // isDstOperand
62440
62441         void execute(GPUDynInstPtr) override;
62442     }; // Inst_DS__DS_MAX_I64
62443
62444     class Inst_DS__DS_MIN_U64 : public Inst_DS
62445     {
62446       public:
62447         Inst_DS__DS_MIN_U64(InFmt_DS*);
62448         ~Inst_DS__DS_MIN_U64();
62449
62450         int
62451         getNumOperands() override
62452         {
62453             return numDstRegOperands() + numSrcRegOperands();
62454         } // getNumOperands
62455
62456         int numDstRegOperands() override { return 0; }
62457         int numSrcRegOperands() override { return 2; }
62458
62459         int
62460         getOperandSize(int opIdx) override
62461         {
62462             switch (opIdx) {
62463               case 0: //vgpr_a
62464                 return 4;
62465               case 1: //vgpr_d0
62466                 return 8;
62467               default:
62468                 fatal("op idx %i out of bounds\n", opIdx);
62469                 return -1;
62470             }
62471         } // getOperandSize
62472
62473         bool
62474         isSrcOperand(int opIdx) override
62475         {
62476             switch (opIdx) {
62477               case 0: //vgpr_a
62478                 return true;
62479               case 1: //vgpr_d0
62480                 return true;
62481               default:
62482                 fatal("op idx %i out of bounds\n", opIdx);
62483                 return false;
62484             }
62485         } // isSrcOperand
62486
62487         bool
62488         isDstOperand(int opIdx) override
62489         {
62490             switch (opIdx) {
62491               case 0: //vgpr_a
62492                 return false;
62493               case 1: //vgpr_d0
62494                 return false;
62495               default:
62496                 fatal("op idx %i out of bounds\n", opIdx);
62497                 return false;
62498             }
62499         } // isDstOperand
62500
62501         void execute(GPUDynInstPtr) override;
62502     }; // Inst_DS__DS_MIN_U64
62503
62504     class Inst_DS__DS_MAX_U64 : public Inst_DS
62505     {
62506       public:
62507         Inst_DS__DS_MAX_U64(InFmt_DS*);
62508         ~Inst_DS__DS_MAX_U64();
62509
62510         int
62511         getNumOperands() override
62512         {
62513             return numDstRegOperands() + numSrcRegOperands();
62514         } // getNumOperands
62515
62516         int numDstRegOperands() override { return 0; }
62517         int numSrcRegOperands() override { return 2; }
62518
62519         int
62520         getOperandSize(int opIdx) override
62521         {
62522             switch (opIdx) {
62523               case 0: //vgpr_a
62524                 return 4;
62525               case 1: //vgpr_d0
62526                 return 8;
62527               default:
62528                 fatal("op idx %i out of bounds\n", opIdx);
62529                 return -1;
62530             }
62531         } // getOperandSize
62532
62533         bool
62534         isSrcOperand(int opIdx) override
62535         {
62536             switch (opIdx) {
62537               case 0: //vgpr_a
62538                 return true;
62539               case 1: //vgpr_d0
62540                 return true;
62541               default:
62542                 fatal("op idx %i out of bounds\n", opIdx);
62543                 return false;
62544             }
62545         } // isSrcOperand
62546
62547         bool
62548         isDstOperand(int opIdx) override
62549         {
62550             switch (opIdx) {
62551               case 0: //vgpr_a
62552                 return false;
62553               case 1: //vgpr_d0
62554                 return false;
62555               default:
62556                 fatal("op idx %i out of bounds\n", opIdx);
62557                 return false;
62558             }
62559         } // isDstOperand
62560
62561         void execute(GPUDynInstPtr) override;
62562     }; // Inst_DS__DS_MAX_U64
62563
62564     class Inst_DS__DS_AND_B64 : public Inst_DS
62565     {
62566       public:
62567         Inst_DS__DS_AND_B64(InFmt_DS*);
62568         ~Inst_DS__DS_AND_B64();
62569
62570         int
62571         getNumOperands() override
62572         {
62573             return numDstRegOperands() + numSrcRegOperands();
62574         } // getNumOperands
62575
62576         int numDstRegOperands() override { return 0; }
62577         int numSrcRegOperands() override { return 2; }
62578
62579         int
62580         getOperandSize(int opIdx) override
62581         {
62582             switch (opIdx) {
62583               case 0: //vgpr_a
62584                 return 4;
62585               case 1: //vgpr_d0
62586                 return 8;
62587               default:
62588                 fatal("op idx %i out of bounds\n", opIdx);
62589                 return -1;
62590             }
62591         } // getOperandSize
62592
62593         bool
62594         isSrcOperand(int opIdx) override
62595         {
62596             switch (opIdx) {
62597               case 0: //vgpr_a
62598                 return true;
62599               case 1: //vgpr_d0
62600                 return true;
62601               default:
62602                 fatal("op idx %i out of bounds\n", opIdx);
62603                 return false;
62604             }
62605         } // isSrcOperand
62606
62607         bool
62608         isDstOperand(int opIdx) override
62609         {
62610             switch (opIdx) {
62611               case 0: //vgpr_a
62612                 return false;
62613               case 1: //vgpr_d0
62614                 return false;
62615               default:
62616                 fatal("op idx %i out of bounds\n", opIdx);
62617                 return false;
62618             }
62619         } // isDstOperand
62620
62621         void execute(GPUDynInstPtr) override;
62622     }; // Inst_DS__DS_AND_B64
62623
62624     class Inst_DS__DS_OR_B64 : public Inst_DS
62625     {
62626       public:
62627         Inst_DS__DS_OR_B64(InFmt_DS*);
62628         ~Inst_DS__DS_OR_B64();
62629
62630         int
62631         getNumOperands() override
62632         {
62633             return numDstRegOperands() + numSrcRegOperands();
62634         } // getNumOperands
62635
62636         int numDstRegOperands() override { return 0; }
62637         int numSrcRegOperands() override { return 2; }
62638
62639         int
62640         getOperandSize(int opIdx) override
62641         {
62642             switch (opIdx) {
62643               case 0: //vgpr_a
62644                 return 4;
62645               case 1: //vgpr_d0
62646                 return 8;
62647               default:
62648                 fatal("op idx %i out of bounds\n", opIdx);
62649                 return -1;
62650             }
62651         } // getOperandSize
62652
62653         bool
62654         isSrcOperand(int opIdx) override
62655         {
62656             switch (opIdx) {
62657               case 0: //vgpr_a
62658                 return true;
62659               case 1: //vgpr_d0
62660                 return true;
62661               default:
62662                 fatal("op idx %i out of bounds\n", opIdx);
62663                 return false;
62664             }
62665         } // isSrcOperand
62666
62667         bool
62668         isDstOperand(int opIdx) override
62669         {
62670             switch (opIdx) {
62671               case 0: //vgpr_a
62672                 return false;
62673               case 1: //vgpr_d0
62674                 return false;
62675               default:
62676                 fatal("op idx %i out of bounds\n", opIdx);
62677                 return false;
62678             }
62679         } // isDstOperand
62680
62681         void execute(GPUDynInstPtr) override;
62682     }; // Inst_DS__DS_OR_B64
62683
62684     class Inst_DS__DS_XOR_B64 : public Inst_DS
62685     {
62686       public:
62687         Inst_DS__DS_XOR_B64(InFmt_DS*);
62688         ~Inst_DS__DS_XOR_B64();
62689
62690         int
62691         getNumOperands() override
62692         {
62693             return numDstRegOperands() + numSrcRegOperands();
62694         } // getNumOperands
62695
62696         int numDstRegOperands() override { return 0; }
62697         int numSrcRegOperands() override { return 2; }
62698
62699         int
62700         getOperandSize(int opIdx) override
62701         {
62702             switch (opIdx) {
62703               case 0: //vgpr_a
62704                 return 4;
62705               case 1: //vgpr_d0
62706                 return 8;
62707               default:
62708                 fatal("op idx %i out of bounds\n", opIdx);
62709                 return -1;
62710             }
62711         } // getOperandSize
62712
62713         bool
62714         isSrcOperand(int opIdx) override
62715         {
62716             switch (opIdx) {
62717               case 0: //vgpr_a
62718                 return true;
62719               case 1: //vgpr_d0
62720                 return true;
62721               default:
62722                 fatal("op idx %i out of bounds\n", opIdx);
62723                 return false;
62724             }
62725         } // isSrcOperand
62726
62727         bool
62728         isDstOperand(int opIdx) override
62729         {
62730             switch (opIdx) {
62731               case 0: //vgpr_a
62732                 return false;
62733               case 1: //vgpr_d0
62734                 return false;
62735               default:
62736                 fatal("op idx %i out of bounds\n", opIdx);
62737                 return false;
62738             }
62739         } // isDstOperand
62740
62741         void execute(GPUDynInstPtr) override;
62742     }; // Inst_DS__DS_XOR_B64
62743
62744     class Inst_DS__DS_MSKOR_B64 : public Inst_DS
62745     {
62746       public:
62747         Inst_DS__DS_MSKOR_B64(InFmt_DS*);
62748         ~Inst_DS__DS_MSKOR_B64();
62749
62750         int
62751         getNumOperands() override
62752         {
62753             return numDstRegOperands() + numSrcRegOperands();
62754         } // getNumOperands
62755
62756         int numDstRegOperands() override { return 0; }
62757         int numSrcRegOperands() override { return 3; }
62758
62759         int
62760         getOperandSize(int opIdx) override
62761         {
62762             switch (opIdx) {
62763               case 0: //vgpr_a
62764                 return 4;
62765               case 1: //vgpr_d1
62766                 return 8;
62767               default:
62768                 fatal("op idx %i out of bounds\n", opIdx);
62769                 return -1;
62770             }
62771         } // getOperandSize
62772
62773         bool
62774         isSrcOperand(int opIdx) override
62775         {
62776             switch (opIdx) {
62777               case 0: //vgpr_a
62778                 return true;
62779               case 1: //vgpr_d1
62780                 return true;
62781               default:
62782                 fatal("op idx %i out of bounds\n", opIdx);
62783                 return false;
62784             }
62785         } // isSrcOperand
62786
62787         bool
62788         isDstOperand(int opIdx) override
62789         {
62790             switch (opIdx) {
62791               case 0: //vgpr_a
62792                 return false;
62793               case 1: //vgpr_d1
62794                 return false;
62795               default:
62796                 fatal("op idx %i out of bounds\n", opIdx);
62797                 return false;
62798             }
62799         } // isDstOperand
62800
62801         void execute(GPUDynInstPtr) override;
62802     }; // Inst_DS__DS_MSKOR_B64
62803
62804     class Inst_DS__DS_WRITE_B64 : public Inst_DS
62805     {
62806       public:
62807         Inst_DS__DS_WRITE_B64(InFmt_DS*);
62808         ~Inst_DS__DS_WRITE_B64();
62809
62810         int
62811         getNumOperands() override
62812         {
62813             return numDstRegOperands() + numSrcRegOperands();
62814         } // getNumOperands
62815
62816         int numDstRegOperands() override { return 0; }
62817         int numSrcRegOperands() override { return 2; }
62818
62819         int
62820         getOperandSize(int opIdx) override
62821         {
62822             switch (opIdx) {
62823               case 0: //vgpr_a
62824                 return 4;
62825               case 1: //vgpr_d0
62826                 return 8;
62827               default:
62828                 fatal("op idx %i out of bounds\n", opIdx);
62829                 return -1;
62830             }
62831         } // getOperandSize
62832
62833         bool
62834         isSrcOperand(int opIdx) override
62835         {
62836             switch (opIdx) {
62837               case 0: //vgpr_a
62838                 return true;
62839               case 1: //vgpr_d0
62840                 return true;
62841               default:
62842                 fatal("op idx %i out of bounds\n", opIdx);
62843                 return false;
62844             }
62845         } // isSrcOperand
62846
62847         bool
62848         isDstOperand(int opIdx) override
62849         {
62850             switch (opIdx) {
62851               case 0: //vgpr_a
62852                 return false;
62853               case 1: //vgpr_d0
62854                 return false;
62855               default:
62856                 fatal("op idx %i out of bounds\n", opIdx);
62857                 return false;
62858             }
62859         } // isDstOperand
62860
62861         void execute(GPUDynInstPtr) override;
62862         void initiateAcc(GPUDynInstPtr) override;
62863         void completeAcc(GPUDynInstPtr) override;
62864     }; // Inst_DS__DS_WRITE_B64
62865
62866     class Inst_DS__DS_WRITE2_B64 : public Inst_DS
62867     {
62868       public:
62869         Inst_DS__DS_WRITE2_B64(InFmt_DS*);
62870         ~Inst_DS__DS_WRITE2_B64();
62871
62872         int
62873         getNumOperands() override
62874         {
62875             return numDstRegOperands() + numSrcRegOperands();
62876         } // getNumOperands
62877
62878         int numDstRegOperands() override { return 0; }
62879         int numSrcRegOperands() override { return 3; }
62880
62881         int
62882         getOperandSize(int opIdx) override
62883         {
62884             switch (opIdx) {
62885               case 0: //vgpr_a
62886                 return 4;
62887               case 1: //vgpr_d0
62888                 return 8;
62889               case 2: //vgpr_d1
62890                 return 8;
62891               default:
62892                 fatal("op idx %i out of bounds\n", opIdx);
62893                 return -1;
62894             }
62895         } // getOperandSize
62896
62897         bool
62898         isSrcOperand(int opIdx) override
62899         {
62900             switch (opIdx) {
62901               case 0: //vgpr_a
62902                 return true;
62903               case 1: //vgpr_d0
62904                 return true;
62905               case 2: //vgpr_d1
62906                 return true;
62907               default:
62908                 fatal("op idx %i out of bounds\n", opIdx);
62909                 return false;
62910             }
62911         } // isSrcOperand
62912
62913         bool
62914         isDstOperand(int opIdx) override
62915         {
62916             switch (opIdx) {
62917               case 0: //vgpr_a
62918                 return false;
62919               case 1: //vgpr_d0
62920                 return false;
62921               case 2: //vgpr_d1
62922                 return false;
62923               default:
62924                 fatal("op idx %i out of bounds\n", opIdx);
62925                 return false;
62926             }
62927         } // isDstOperand
62928
62929         void execute(GPUDynInstPtr) override;
62930         void initiateAcc(GPUDynInstPtr) override;
62931         void completeAcc(GPUDynInstPtr) override;
62932     }; // Inst_DS__DS_WRITE2_B64
62933
62934     class Inst_DS__DS_WRITE2ST64_B64 : public Inst_DS
62935     {
62936       public:
62937         Inst_DS__DS_WRITE2ST64_B64(InFmt_DS*);
62938         ~Inst_DS__DS_WRITE2ST64_B64();
62939
62940         int
62941         getNumOperands() override
62942         {
62943             return numDstRegOperands() + numSrcRegOperands();
62944         } // getNumOperands
62945
62946         int numDstRegOperands() override { return 0; }
62947         int numSrcRegOperands() override { return 3; }
62948
62949         int
62950         getOperandSize(int opIdx) override
62951         {
62952             switch (opIdx) {
62953               case 0: //vgpr_a
62954                 return 4;
62955               case 1: //vgpr_d1
62956                 return 8;
62957               default:
62958                 fatal("op idx %i out of bounds\n", opIdx);
62959                 return -1;
62960             }
62961         } // getOperandSize
62962
62963         bool
62964         isSrcOperand(int opIdx) override
62965         {
62966             switch (opIdx) {
62967               case 0: //vgpr_a
62968                 return true;
62969               case 1: //vgpr_d1
62970                 return true;
62971               default:
62972                 fatal("op idx %i out of bounds\n", opIdx);
62973                 return false;
62974             }
62975         } // isSrcOperand
62976
62977         bool
62978         isDstOperand(int opIdx) override
62979         {
62980             switch (opIdx) {
62981               case 0: //vgpr_a
62982                 return false;
62983               case 1: //vgpr_d1
62984                 return false;
62985               default:
62986                 fatal("op idx %i out of bounds\n", opIdx);
62987                 return false;
62988             }
62989         } // isDstOperand
62990
62991         void execute(GPUDynInstPtr) override;
62992     }; // Inst_DS__DS_WRITE2ST64_B64
62993
62994     class Inst_DS__DS_CMPST_B64 : public Inst_DS
62995     {
62996       public:
62997         Inst_DS__DS_CMPST_B64(InFmt_DS*);
62998         ~Inst_DS__DS_CMPST_B64();
62999
63000         int
63001         getNumOperands() override
63002         {
63003             return numDstRegOperands() + numSrcRegOperands();
63004         } // getNumOperands
63005
63006         int numDstRegOperands() override { return 0; }
63007         int numSrcRegOperands() override { return 3; }
63008
63009         int
63010         getOperandSize(int opIdx) override
63011         {
63012             switch (opIdx) {
63013               case 0: //vgpr_a
63014                 return 4;
63015               case 1: //vgpr_d1
63016                 return 8;
63017               default:
63018                 fatal("op idx %i out of bounds\n", opIdx);
63019                 return -1;
63020             }
63021         } // getOperandSize
63022
63023         bool
63024         isSrcOperand(int opIdx) override
63025         {
63026             switch (opIdx) {
63027               case 0: //vgpr_a
63028                 return true;
63029               case 1: //vgpr_d1
63030                 return true;
63031               default:
63032                 fatal("op idx %i out of bounds\n", opIdx);
63033                 return false;
63034             }
63035         } // isSrcOperand
63036
63037         bool
63038         isDstOperand(int opIdx) override
63039         {
63040             switch (opIdx) {
63041               case 0: //vgpr_a
63042                 return false;
63043               case 1: //vgpr_d1
63044                 return false;
63045               default:
63046                 fatal("op idx %i out of bounds\n", opIdx);
63047                 return false;
63048             }
63049         } // isDstOperand
63050
63051         void execute(GPUDynInstPtr) override;
63052     }; // Inst_DS__DS_CMPST_B64
63053
63054     class Inst_DS__DS_CMPST_F64 : public Inst_DS
63055     {
63056       public:
63057         Inst_DS__DS_CMPST_F64(InFmt_DS*);
63058         ~Inst_DS__DS_CMPST_F64();
63059
63060         int
63061         getNumOperands() override
63062         {
63063             return numDstRegOperands() + numSrcRegOperands();
63064         } // getNumOperands
63065
63066         int numDstRegOperands() override { return 0; }
63067         int numSrcRegOperands() override { return 3; }
63068
63069         int
63070         getOperandSize(int opIdx) override
63071         {
63072             switch (opIdx) {
63073               case 0: //vgpr_a
63074                 return 4;
63075               case 1: //vgpr_d1
63076                 return 8;
63077               default:
63078                 fatal("op idx %i out of bounds\n", opIdx);
63079                 return -1;
63080             }
63081         } // getOperandSize
63082
63083         bool
63084         isSrcOperand(int opIdx) override
63085         {
63086             switch (opIdx) {
63087               case 0: //vgpr_a
63088                 return true;
63089               case 1: //vgpr_d1
63090                 return true;
63091               default:
63092                 fatal("op idx %i out of bounds\n", opIdx);
63093                 return false;
63094             }
63095         } // isSrcOperand
63096
63097         bool
63098         isDstOperand(int opIdx) override
63099         {
63100             switch (opIdx) {
63101               case 0: //vgpr_a
63102                 return false;
63103               case 1: //vgpr_d1
63104                 return false;
63105               default:
63106                 fatal("op idx %i out of bounds\n", opIdx);
63107                 return false;
63108             }
63109         } // isDstOperand
63110
63111         void execute(GPUDynInstPtr) override;
63112     }; // Inst_DS__DS_CMPST_F64
63113
63114     class Inst_DS__DS_MIN_F64 : public Inst_DS
63115     {
63116       public:
63117         Inst_DS__DS_MIN_F64(InFmt_DS*);
63118         ~Inst_DS__DS_MIN_F64();
63119
63120         int
63121         getNumOperands() override
63122         {
63123             return numDstRegOperands() + numSrcRegOperands();
63124         } // getNumOperands
63125
63126         int numDstRegOperands() override { return 0; }
63127         int numSrcRegOperands() override { return 2; }
63128
63129         int
63130         getOperandSize(int opIdx) override
63131         {
63132             switch (opIdx) {
63133               case 0: //vgpr_a
63134                 return 4;
63135               case 1: //vgpr_d0
63136                 return 8;
63137               default:
63138                 fatal("op idx %i out of bounds\n", opIdx);
63139                 return -1;
63140             }
63141         } // getOperandSize
63142
63143         bool
63144         isSrcOperand(int opIdx) override
63145         {
63146             switch (opIdx) {
63147               case 0: //vgpr_a
63148                 return true;
63149               case 1: //vgpr_d0
63150                 return true;
63151               default:
63152                 fatal("op idx %i out of bounds\n", opIdx);
63153                 return false;
63154             }
63155         } // isSrcOperand
63156
63157         bool
63158         isDstOperand(int opIdx) override
63159         {
63160             switch (opIdx) {
63161               case 0: //vgpr_a
63162                 return false;
63163               case 1: //vgpr_d0
63164                 return false;
63165               default:
63166                 fatal("op idx %i out of bounds\n", opIdx);
63167                 return false;
63168             }
63169         } // isDstOperand
63170
63171         void execute(GPUDynInstPtr) override;
63172     }; // Inst_DS__DS_MIN_F64
63173
63174     class Inst_DS__DS_MAX_F64 : public Inst_DS
63175     {
63176       public:
63177         Inst_DS__DS_MAX_F64(InFmt_DS*);
63178         ~Inst_DS__DS_MAX_F64();
63179
63180         int
63181         getNumOperands() override
63182         {
63183             return numDstRegOperands() + numSrcRegOperands();
63184         } // getNumOperands
63185
63186         int numDstRegOperands() override { return 0; }
63187         int numSrcRegOperands() override { return 2; }
63188
63189         int
63190         getOperandSize(int opIdx) override
63191         {
63192             switch (opIdx) {
63193               case 0: //vgpr_a
63194                 return 4;
63195               case 1: //vgpr_d0
63196                 return 8;
63197               default:
63198                 fatal("op idx %i out of bounds\n", opIdx);
63199                 return -1;
63200             }
63201         } // getOperandSize
63202
63203         bool
63204         isSrcOperand(int opIdx) override
63205         {
63206             switch (opIdx) {
63207               case 0: //vgpr_a
63208                 return true;
63209               case 1: //vgpr_d0
63210                 return true;
63211               default:
63212                 fatal("op idx %i out of bounds\n", opIdx);
63213                 return false;
63214             }
63215         } // isSrcOperand
63216
63217         bool
63218         isDstOperand(int opIdx) override
63219         {
63220             switch (opIdx) {
63221               case 0: //vgpr_a
63222                 return false;
63223               case 1: //vgpr_d0
63224                 return false;
63225               default:
63226                 fatal("op idx %i out of bounds\n", opIdx);
63227                 return false;
63228             }
63229         } // isDstOperand
63230
63231         void execute(GPUDynInstPtr) override;
63232     }; // Inst_DS__DS_MAX_F64
63233
63234     class Inst_DS__DS_ADD_RTN_U64 : public Inst_DS
63235     {
63236       public:
63237         Inst_DS__DS_ADD_RTN_U64(InFmt_DS*);
63238         ~Inst_DS__DS_ADD_RTN_U64();
63239
63240         int
63241         getNumOperands() override
63242         {
63243             return numDstRegOperands() + numSrcRegOperands();
63244         } // getNumOperands
63245
63246         int numDstRegOperands() override { return 1; }
63247         int numSrcRegOperands() override { return 2; }
63248
63249         int
63250         getOperandSize(int opIdx) override
63251         {
63252             switch (opIdx) {
63253               case 0: //vgpr_a
63254                 return 4;
63255               case 1: //vgpr_d0
63256                 return 8;
63257               case 2: //vgpr_rtn
63258                 return 8;
63259               default:
63260                 fatal("op idx %i out of bounds\n", opIdx);
63261                 return -1;
63262             }
63263         } // getOperandSize
63264
63265         bool
63266         isSrcOperand(int opIdx) override
63267         {
63268             switch (opIdx) {
63269               case 0: //vgpr_a
63270                 return true;
63271               case 1: //vgpr_d0
63272                 return true;
63273               case 2: //vgpr_rtn
63274                 return false;
63275               default:
63276                 fatal("op idx %i out of bounds\n", opIdx);
63277                 return false;
63278             }
63279         } // isSrcOperand
63280
63281         bool
63282         isDstOperand(int opIdx) override
63283         {
63284             switch (opIdx) {
63285               case 0: //vgpr_a
63286                 return false;
63287               case 1: //vgpr_d0
63288                 return false;
63289               case 2: //vgpr_rtn
63290                 return true;
63291               default:
63292                 fatal("op idx %i out of bounds\n", opIdx);
63293                 return false;
63294             }
63295         } // isDstOperand
63296
63297         void execute(GPUDynInstPtr) override;
63298     }; // Inst_DS__DS_ADD_RTN_U64
63299
63300     class Inst_DS__DS_SUB_RTN_U64 : public Inst_DS
63301     {
63302       public:
63303         Inst_DS__DS_SUB_RTN_U64(InFmt_DS*);
63304         ~Inst_DS__DS_SUB_RTN_U64();
63305
63306         int
63307         getNumOperands() override
63308         {
63309             return numDstRegOperands() + numSrcRegOperands();
63310         } // getNumOperands
63311
63312         int numDstRegOperands() override { return 1; }
63313         int numSrcRegOperands() override { return 2; }
63314
63315         int
63316         getOperandSize(int opIdx) override
63317         {
63318             switch (opIdx) {
63319               case 0: //vgpr_a
63320                 return 4;
63321               case 1: //vgpr_d0
63322                 return 8;
63323               case 2: //vgpr_rtn
63324                 return 8;
63325               default:
63326                 fatal("op idx %i out of bounds\n", opIdx);
63327                 return -1;
63328             }
63329         } // getOperandSize
63330
63331         bool
63332         isSrcOperand(int opIdx) override
63333         {
63334             switch (opIdx) {
63335               case 0: //vgpr_a
63336                 return true;
63337               case 1: //vgpr_d0
63338                 return true;
63339               case 2: //vgpr_rtn
63340                 return false;
63341               default:
63342                 fatal("op idx %i out of bounds\n", opIdx);
63343                 return false;
63344             }
63345         } // isSrcOperand
63346
63347         bool
63348         isDstOperand(int opIdx) override
63349         {
63350             switch (opIdx) {
63351               case 0: //vgpr_a
63352                 return false;
63353               case 1: //vgpr_d0
63354                 return false;
63355               case 2: //vgpr_rtn
63356                 return true;
63357               default:
63358                 fatal("op idx %i out of bounds\n", opIdx);
63359                 return false;
63360             }
63361         } // isDstOperand
63362
63363         void execute(GPUDynInstPtr) override;
63364     }; // Inst_DS__DS_SUB_RTN_U64
63365
63366     class Inst_DS__DS_RSUB_RTN_U64 : public Inst_DS
63367     {
63368       public:
63369         Inst_DS__DS_RSUB_RTN_U64(InFmt_DS*);
63370         ~Inst_DS__DS_RSUB_RTN_U64();
63371
63372         int
63373         getNumOperands() override
63374         {
63375             return numDstRegOperands() + numSrcRegOperands();
63376         } // getNumOperands
63377
63378         int numDstRegOperands() override { return 1; }
63379         int numSrcRegOperands() override { return 2; }
63380
63381         int
63382         getOperandSize(int opIdx) override
63383         {
63384             switch (opIdx) {
63385               case 0: //vgpr_a
63386                 return 4;
63387               case 1: //vgpr_d0
63388                 return 8;
63389               case 2: //vgpr_rtn
63390                 return 8;
63391               default:
63392                 fatal("op idx %i out of bounds\n", opIdx);
63393                 return -1;
63394             }
63395         } // getOperandSize
63396
63397         bool
63398         isSrcOperand(int opIdx) override
63399         {
63400             switch (opIdx) {
63401               case 0: //vgpr_a
63402                 return true;
63403               case 1: //vgpr_d0
63404                 return true;
63405               case 2: //vgpr_rtn
63406                 return false;
63407               default:
63408                 fatal("op idx %i out of bounds\n", opIdx);
63409                 return false;
63410             }
63411         } // isSrcOperand
63412
63413         bool
63414         isDstOperand(int opIdx) override
63415         {
63416             switch (opIdx) {
63417               case 0: //vgpr_a
63418                 return false;
63419               case 1: //vgpr_d0
63420                 return false;
63421               case 2: //vgpr_rtn
63422                 return true;
63423               default:
63424                 fatal("op idx %i out of bounds\n", opIdx);
63425                 return false;
63426             }
63427         } // isDstOperand
63428
63429         void execute(GPUDynInstPtr) override;
63430     }; // Inst_DS__DS_RSUB_RTN_U64
63431
63432     class Inst_DS__DS_INC_RTN_U64 : public Inst_DS
63433     {
63434       public:
63435         Inst_DS__DS_INC_RTN_U64(InFmt_DS*);
63436         ~Inst_DS__DS_INC_RTN_U64();
63437
63438         int
63439         getNumOperands() override
63440         {
63441             return numDstRegOperands() + numSrcRegOperands();
63442         } // getNumOperands
63443
63444         int numDstRegOperands() override { return 1; }
63445         int numSrcRegOperands() override { return 2; }
63446
63447         int
63448         getOperandSize(int opIdx) override
63449         {
63450             switch (opIdx) {
63451               case 0: //vgpr_a
63452                 return 4;
63453               case 1: //vgpr_d0
63454                 return 8;
63455               case 2: //vgpr_rtn
63456                 return 8;
63457               default:
63458                 fatal("op idx %i out of bounds\n", opIdx);
63459                 return -1;
63460             }
63461         } // getOperandSize
63462
63463         bool
63464         isSrcOperand(int opIdx) override
63465         {
63466             switch (opIdx) {
63467               case 0: //vgpr_a
63468                 return true;
63469               case 1: //vgpr_d0
63470                 return true;
63471               case 2: //vgpr_rtn
63472                 return false;
63473               default:
63474                 fatal("op idx %i out of bounds\n", opIdx);
63475                 return false;
63476             }
63477         } // isSrcOperand
63478
63479         bool
63480         isDstOperand(int opIdx) override
63481         {
63482             switch (opIdx) {
63483               case 0: //vgpr_a
63484                 return false;
63485               case 1: //vgpr_d0
63486                 return false;
63487               case 2: //vgpr_rtn
63488                 return true;
63489               default:
63490                 fatal("op idx %i out of bounds\n", opIdx);
63491                 return false;
63492             }
63493         } // isDstOperand
63494
63495         void execute(GPUDynInstPtr) override;
63496     }; // Inst_DS__DS_INC_RTN_U64
63497
63498     class Inst_DS__DS_DEC_RTN_U64 : public Inst_DS
63499     {
63500       public:
63501         Inst_DS__DS_DEC_RTN_U64(InFmt_DS*);
63502         ~Inst_DS__DS_DEC_RTN_U64();
63503
63504         int
63505         getNumOperands() override
63506         {
63507             return numDstRegOperands() + numSrcRegOperands();
63508         } // getNumOperands
63509
63510         int numDstRegOperands() override { return 1; }
63511         int numSrcRegOperands() override { return 2; }
63512
63513         int
63514         getOperandSize(int opIdx) override
63515         {
63516             switch (opIdx) {
63517               case 0: //vgpr_a
63518                 return 4;
63519               case 1: //vgpr_d0
63520                 return 8;
63521               case 2: //vgpr_rtn
63522                 return 8;
63523               default:
63524                 fatal("op idx %i out of bounds\n", opIdx);
63525                 return -1;
63526             }
63527         } // getOperandSize
63528
63529         bool
63530         isSrcOperand(int opIdx) override
63531         {
63532             switch (opIdx) {
63533               case 0: //vgpr_a
63534                 return true;
63535               case 1: //vgpr_d0
63536                 return true;
63537               case 2: //vgpr_rtn
63538                 return false;
63539               default:
63540                 fatal("op idx %i out of bounds\n", opIdx);
63541                 return false;
63542             }
63543         } // isSrcOperand
63544
63545         bool
63546         isDstOperand(int opIdx) override
63547         {
63548             switch (opIdx) {
63549               case 0: //vgpr_a
63550                 return false;
63551               case 1: //vgpr_d0
63552                 return false;
63553               case 2: //vgpr_rtn
63554                 return true;
63555               default:
63556                 fatal("op idx %i out of bounds\n", opIdx);
63557                 return false;
63558             }
63559         } // isDstOperand
63560
63561         void execute(GPUDynInstPtr) override;
63562     }; // Inst_DS__DS_DEC_RTN_U64
63563
63564     class Inst_DS__DS_MIN_RTN_I64 : public Inst_DS
63565     {
63566       public:
63567         Inst_DS__DS_MIN_RTN_I64(InFmt_DS*);
63568         ~Inst_DS__DS_MIN_RTN_I64();
63569
63570         int
63571         getNumOperands() override
63572         {
63573             return numDstRegOperands() + numSrcRegOperands();
63574         } // getNumOperands
63575
63576         int numDstRegOperands() override { return 1; }
63577         int numSrcRegOperands() override { return 2; }
63578
63579         int
63580         getOperandSize(int opIdx) override
63581         {
63582             switch (opIdx) {
63583               case 0: //vgpr_a
63584                 return 4;
63585               case 1: //vgpr_d0
63586                 return 8;
63587               case 2: //vgpr_rtn
63588                 return 8;
63589               default:
63590                 fatal("op idx %i out of bounds\n", opIdx);
63591                 return -1;
63592             }
63593         } // getOperandSize
63594
63595         bool
63596         isSrcOperand(int opIdx) override
63597         {
63598             switch (opIdx) {
63599               case 0: //vgpr_a
63600                 return true;
63601               case 1: //vgpr_d0
63602                 return true;
63603               case 2: //vgpr_rtn
63604                 return false;
63605               default:
63606                 fatal("op idx %i out of bounds\n", opIdx);
63607                 return false;
63608             }
63609         } // isSrcOperand
63610
63611         bool
63612         isDstOperand(int opIdx) override
63613         {
63614             switch (opIdx) {
63615               case 0: //vgpr_a
63616                 return false;
63617               case 1: //vgpr_d0
63618                 return false;
63619               case 2: //vgpr_rtn
63620                 return true;
63621               default:
63622                 fatal("op idx %i out of bounds\n", opIdx);
63623                 return false;
63624             }
63625         } // isDstOperand
63626
63627         void execute(GPUDynInstPtr) override;
63628     }; // Inst_DS__DS_MIN_RTN_I64
63629
63630     class Inst_DS__DS_MAX_RTN_I64 : public Inst_DS
63631     {
63632       public:
63633         Inst_DS__DS_MAX_RTN_I64(InFmt_DS*);
63634         ~Inst_DS__DS_MAX_RTN_I64();
63635
63636         int
63637         getNumOperands() override
63638         {
63639             return numDstRegOperands() + numSrcRegOperands();
63640         } // getNumOperands
63641
63642         int numDstRegOperands() override { return 1; }
63643         int numSrcRegOperands() override { return 2; }
63644
63645         int
63646         getOperandSize(int opIdx) override
63647         {
63648             switch (opIdx) {
63649               case 0: //vgpr_a
63650                 return 4;
63651               case 1: //vgpr_d0
63652                 return 8;
63653               case 2: //vgpr_rtn
63654                 return 8;
63655               default:
63656                 fatal("op idx %i out of bounds\n", opIdx);
63657                 return -1;
63658             }
63659         } // getOperandSize
63660
63661         bool
63662         isSrcOperand(int opIdx) override
63663         {
63664             switch (opIdx) {
63665               case 0: //vgpr_a
63666                 return true;
63667               case 1: //vgpr_d0
63668                 return true;
63669               case 2: //vgpr_rtn
63670                 return false;
63671               default:
63672                 fatal("op idx %i out of bounds\n", opIdx);
63673                 return false;
63674             }
63675         } // isSrcOperand
63676
63677         bool
63678         isDstOperand(int opIdx) override
63679         {
63680             switch (opIdx) {
63681               case 0: //vgpr_a
63682                 return false;
63683               case 1: //vgpr_d0
63684                 return false;
63685               case 2: //vgpr_rtn
63686                 return true;
63687               default:
63688                 fatal("op idx %i out of bounds\n", opIdx);
63689                 return false;
63690             }
63691         } // isDstOperand
63692
63693         void execute(GPUDynInstPtr) override;
63694     }; // Inst_DS__DS_MAX_RTN_I64
63695
63696     class Inst_DS__DS_MIN_RTN_U64 : public Inst_DS
63697     {
63698       public:
63699         Inst_DS__DS_MIN_RTN_U64(InFmt_DS*);
63700         ~Inst_DS__DS_MIN_RTN_U64();
63701
63702         int
63703         getNumOperands() override
63704         {
63705             return numDstRegOperands() + numSrcRegOperands();
63706         } // getNumOperands
63707
63708         int numDstRegOperands() override { return 1; }
63709         int numSrcRegOperands() override { return 2; }
63710
63711         int
63712         getOperandSize(int opIdx) override
63713         {
63714             switch (opIdx) {
63715               case 0: //vgpr_a
63716                 return 4;
63717               case 1: //vgpr_d0
63718                 return 8;
63719               case 2: //vgpr_rtn
63720                 return 8;
63721               default:
63722                 fatal("op idx %i out of bounds\n", opIdx);
63723                 return -1;
63724             }
63725         } // getOperandSize
63726
63727         bool
63728         isSrcOperand(int opIdx) override
63729         {
63730             switch (opIdx) {
63731               case 0: //vgpr_a
63732                 return true;
63733               case 1: //vgpr_d0
63734                 return true;
63735               case 2: //vgpr_rtn
63736                 return false;
63737               default:
63738                 fatal("op idx %i out of bounds\n", opIdx);
63739                 return false;
63740             }
63741         } // isSrcOperand
63742
63743         bool
63744         isDstOperand(int opIdx) override
63745         {
63746             switch (opIdx) {
63747               case 0: //vgpr_a
63748                 return false;
63749               case 1: //vgpr_d0
63750                 return false;
63751               case 2: //vgpr_rtn
63752                 return true;
63753               default:
63754                 fatal("op idx %i out of bounds\n", opIdx);
63755                 return false;
63756             }
63757         } // isDstOperand
63758
63759         void execute(GPUDynInstPtr) override;
63760     }; // Inst_DS__DS_MIN_RTN_U64
63761
63762     class Inst_DS__DS_MAX_RTN_U64 : public Inst_DS
63763     {
63764       public:
63765         Inst_DS__DS_MAX_RTN_U64(InFmt_DS*);
63766         ~Inst_DS__DS_MAX_RTN_U64();
63767
63768         int
63769         getNumOperands() override
63770         {
63771             return numDstRegOperands() + numSrcRegOperands();
63772         } // getNumOperands
63773
63774         int numDstRegOperands() override { return 1; }
63775         int numSrcRegOperands() override { return 2; }
63776
63777         int
63778         getOperandSize(int opIdx) override
63779         {
63780             switch (opIdx) {
63781               case 0: //vgpr_a
63782                 return 4;
63783               case 1: //vgpr_d0
63784                 return 8;
63785               case 2: //vgpr_rtn
63786                 return 8;
63787               default:
63788                 fatal("op idx %i out of bounds\n", opIdx);
63789                 return -1;
63790             }
63791         } // getOperandSize
63792
63793         bool
63794         isSrcOperand(int opIdx) override
63795         {
63796             switch (opIdx) {
63797               case 0: //vgpr_a
63798                 return true;
63799               case 1: //vgpr_d0
63800                 return true;
63801               case 2: //vgpr_rtn
63802                 return false;
63803               default:
63804                 fatal("op idx %i out of bounds\n", opIdx);
63805                 return false;
63806             }
63807         } // isSrcOperand
63808
63809         bool
63810         isDstOperand(int opIdx) override
63811         {
63812             switch (opIdx) {
63813               case 0: //vgpr_a
63814                 return false;
63815               case 1: //vgpr_d0
63816                 return false;
63817               case 2: //vgpr_rtn
63818                 return true;
63819               default:
63820                 fatal("op idx %i out of bounds\n", opIdx);
63821                 return false;
63822             }
63823         } // isDstOperand
63824
63825         void execute(GPUDynInstPtr) override;
63826     }; // Inst_DS__DS_MAX_RTN_U64
63827
63828     class Inst_DS__DS_AND_RTN_B64 : public Inst_DS
63829     {
63830       public:
63831         Inst_DS__DS_AND_RTN_B64(InFmt_DS*);
63832         ~Inst_DS__DS_AND_RTN_B64();
63833
63834         int
63835         getNumOperands() override
63836         {
63837             return numDstRegOperands() + numSrcRegOperands();
63838         } // getNumOperands
63839
63840         int numDstRegOperands() override { return 1; }
63841         int numSrcRegOperands() override { return 2; }
63842
63843         int
63844         getOperandSize(int opIdx) override
63845         {
63846             switch (opIdx) {
63847               case 0: //vgpr_a
63848                 return 4;
63849               case 1: //vgpr_d0
63850                 return 8;
63851               case 2: //vgpr_rtn
63852                 return 8;
63853               default:
63854                 fatal("op idx %i out of bounds\n", opIdx);
63855                 return -1;
63856             }
63857         } // getOperandSize
63858
63859         bool
63860         isSrcOperand(int opIdx) override
63861         {
63862             switch (opIdx) {
63863               case 0: //vgpr_a
63864                 return true;
63865               case 1: //vgpr_d0
63866                 return true;
63867               case 2: //vgpr_rtn
63868                 return false;
63869               default:
63870                 fatal("op idx %i out of bounds\n", opIdx);
63871                 return false;
63872             }
63873         } // isSrcOperand
63874
63875         bool
63876         isDstOperand(int opIdx) override
63877         {
63878             switch (opIdx) {
63879               case 0: //vgpr_a
63880                 return false;
63881               case 1: //vgpr_d0
63882                 return false;
63883               case 2: //vgpr_rtn
63884                 return true;
63885               default:
63886                 fatal("op idx %i out of bounds\n", opIdx);
63887                 return false;
63888             }
63889         } // isDstOperand
63890
63891         void execute(GPUDynInstPtr) override;
63892     }; // Inst_DS__DS_AND_RTN_B64
63893
63894     class Inst_DS__DS_OR_RTN_B64 : public Inst_DS
63895     {
63896       public:
63897         Inst_DS__DS_OR_RTN_B64(InFmt_DS*);
63898         ~Inst_DS__DS_OR_RTN_B64();
63899
63900         int
63901         getNumOperands() override
63902         {
63903             return numDstRegOperands() + numSrcRegOperands();
63904         } // getNumOperands
63905
63906         int numDstRegOperands() override { return 1; }
63907         int numSrcRegOperands() override { return 2; }
63908
63909         int
63910         getOperandSize(int opIdx) override
63911         {
63912             switch (opIdx) {
63913               case 0: //vgpr_a
63914                 return 4;
63915               case 1: //vgpr_d0
63916                 return 8;
63917               case 2: //vgpr_rtn
63918                 return 8;
63919               default:
63920                 fatal("op idx %i out of bounds\n", opIdx);
63921                 return -1;
63922             }
63923         } // getOperandSize
63924
63925         bool
63926         isSrcOperand(int opIdx) override
63927         {
63928             switch (opIdx) {
63929               case 0: //vgpr_a
63930                 return true;
63931               case 1: //vgpr_d0
63932                 return true;
63933               case 2: //vgpr_rtn
63934                 return false;
63935               default:
63936                 fatal("op idx %i out of bounds\n", opIdx);
63937                 return false;
63938             }
63939         } // isSrcOperand
63940
63941         bool
63942         isDstOperand(int opIdx) override
63943         {
63944             switch (opIdx) {
63945               case 0: //vgpr_a
63946                 return false;
63947               case 1: //vgpr_d0
63948                 return false;
63949               case 2: //vgpr_rtn
63950                 return true;
63951               default:
63952                 fatal("op idx %i out of bounds\n", opIdx);
63953                 return false;
63954             }
63955         } // isDstOperand
63956
63957         void execute(GPUDynInstPtr) override;
63958     }; // Inst_DS__DS_OR_RTN_B64
63959
63960     class Inst_DS__DS_XOR_RTN_B64 : public Inst_DS
63961     {
63962       public:
63963         Inst_DS__DS_XOR_RTN_B64(InFmt_DS*);
63964         ~Inst_DS__DS_XOR_RTN_B64();
63965
63966         int
63967         getNumOperands() override
63968         {
63969             return numDstRegOperands() + numSrcRegOperands();
63970         } // getNumOperands
63971
63972         int numDstRegOperands() override { return 1; }
63973         int numSrcRegOperands() override { return 2; }
63974
63975         int
63976         getOperandSize(int opIdx) override
63977         {
63978             switch (opIdx) {
63979               case 0: //vgpr_a
63980                 return 4;
63981               case 1: //vgpr_d0
63982                 return 8;
63983               case 2: //vgpr_rtn
63984                 return 8;
63985               default:
63986                 fatal("op idx %i out of bounds\n", opIdx);
63987                 return -1;
63988             }
63989         } // getOperandSize
63990
63991         bool
63992         isSrcOperand(int opIdx) override
63993         {
63994             switch (opIdx) {
63995               case 0: //vgpr_a
63996                 return true;
63997               case 1: //vgpr_d0
63998                 return true;
63999               case 2: //vgpr_rtn
64000                 return false;
64001               default:
64002                 fatal("op idx %i out of bounds\n", opIdx);
64003                 return false;
64004             }
64005         } // isSrcOperand
64006
64007         bool
64008         isDstOperand(int opIdx) override
64009         {
64010             switch (opIdx) {
64011               case 0: //vgpr_a
64012                 return false;
64013               case 1: //vgpr_d0
64014                 return false;
64015               case 2: //vgpr_rtn
64016                 return true;
64017               default:
64018                 fatal("op idx %i out of bounds\n", opIdx);
64019                 return false;
64020             }
64021         } // isDstOperand
64022
64023         void execute(GPUDynInstPtr) override;
64024     }; // Inst_DS__DS_XOR_RTN_B64
64025
64026     class Inst_DS__DS_MSKOR_RTN_B64 : public Inst_DS
64027     {
64028       public:
64029         Inst_DS__DS_MSKOR_RTN_B64(InFmt_DS*);
64030         ~Inst_DS__DS_MSKOR_RTN_B64();
64031
64032         int
64033         getNumOperands() override
64034         {
64035             return numDstRegOperands() + numSrcRegOperands();
64036         } // getNumOperands
64037
64038         int numDstRegOperands() override { return 1; }
64039         int numSrcRegOperands() override { return 3; }
64040
64041         int
64042         getOperandSize(int opIdx) override
64043         {
64044             switch (opIdx) {
64045               case 0: //vgpr_a
64046                 return 4;
64047               case 1: //vgpr_d1
64048                 return 8;
64049               case 2: //vgpr_rtn
64050                 return 8;
64051               default:
64052                 fatal("op idx %i out of bounds\n", opIdx);
64053                 return -1;
64054             }
64055         } // getOperandSize
64056
64057         bool
64058         isSrcOperand(int opIdx) override
64059         {
64060             switch (opIdx) {
64061               case 0: //vgpr_a
64062                 return true;
64063               case 1: //vgpr_d1
64064                 return true;
64065               case 2: //vgpr_rtn
64066                 return false;
64067               default:
64068                 fatal("op idx %i out of bounds\n", opIdx);
64069                 return false;
64070             }
64071         } // isSrcOperand
64072
64073         bool
64074         isDstOperand(int opIdx) override
64075         {
64076             switch (opIdx) {
64077               case 0: //vgpr_a
64078                 return false;
64079               case 1: //vgpr_d1
64080                 return false;
64081               case 2: //vgpr_rtn
64082                 return true;
64083               default:
64084                 fatal("op idx %i out of bounds\n", opIdx);
64085                 return false;
64086             }
64087         } // isDstOperand
64088
64089         void execute(GPUDynInstPtr) override;
64090     }; // Inst_DS__DS_MSKOR_RTN_B64
64091
64092     class Inst_DS__DS_WRXCHG_RTN_B64 : public Inst_DS
64093     {
64094       public:
64095         Inst_DS__DS_WRXCHG_RTN_B64(InFmt_DS*);
64096         ~Inst_DS__DS_WRXCHG_RTN_B64();
64097
64098         int
64099         getNumOperands() override
64100         {
64101             return numDstRegOperands() + numSrcRegOperands();
64102         } // getNumOperands
64103
64104         int numDstRegOperands() override { return 1; }
64105         int numSrcRegOperands() override { return 2; }
64106
64107         int
64108         getOperandSize(int opIdx) override
64109         {
64110             switch (opIdx) {
64111               case 0: //vgpr_a
64112                 return 4;
64113               case 1: //vgpr_d0
64114                 return 8;
64115               case 2: //vgpr_rtn
64116                 return 8;
64117               default:
64118                 fatal("op idx %i out of bounds\n", opIdx);
64119                 return -1;
64120             }
64121         } // getOperandSize
64122
64123         bool
64124         isSrcOperand(int opIdx) override
64125         {
64126             switch (opIdx) {
64127               case 0: //vgpr_a
64128                 return true;
64129               case 1: //vgpr_d0
64130                 return true;
64131               case 2: //vgpr_rtn
64132                 return false;
64133               default:
64134                 fatal("op idx %i out of bounds\n", opIdx);
64135                 return false;
64136             }
64137         } // isSrcOperand
64138
64139         bool
64140         isDstOperand(int opIdx) override
64141         {
64142             switch (opIdx) {
64143               case 0: //vgpr_a
64144                 return false;
64145               case 1: //vgpr_d0
64146                 return false;
64147               case 2: //vgpr_rtn
64148                 return true;
64149               default:
64150                 fatal("op idx %i out of bounds\n", opIdx);
64151                 return false;
64152             }
64153         } // isDstOperand
64154
64155         void execute(GPUDynInstPtr) override;
64156     }; // Inst_DS__DS_WRXCHG_RTN_B64
64157
64158     class Inst_DS__DS_WRXCHG2_RTN_B64 : public Inst_DS
64159     {
64160       public:
64161         Inst_DS__DS_WRXCHG2_RTN_B64(InFmt_DS*);
64162         ~Inst_DS__DS_WRXCHG2_RTN_B64();
64163
64164         int
64165         getNumOperands() override
64166         {
64167             return numDstRegOperands() + numSrcRegOperands();
64168         } // getNumOperands
64169
64170         int numDstRegOperands() override { return 1; }
64171         int numSrcRegOperands() override { return 3; }
64172
64173         int
64174         getOperandSize(int opIdx) override
64175         {
64176             switch (opIdx) {
64177               case 0: //vgpr_a
64178                 return 4;
64179               case 1: //vgpr_d1
64180                 return 8;
64181               case 2: //vgpr_rtn
64182                 return 8;
64183               default:
64184                 fatal("op idx %i out of bounds\n", opIdx);
64185                 return -1;
64186             }
64187         } // getOperandSize
64188
64189         bool
64190         isSrcOperand(int opIdx) override
64191         {
64192             switch (opIdx) {
64193               case 0: //vgpr_a
64194                 return true;
64195               case 1: //vgpr_d1
64196                 return true;
64197               case 2: //vgpr_rtn
64198                 return false;
64199               default:
64200                 fatal("op idx %i out of bounds\n", opIdx);
64201                 return false;
64202             }
64203         } // isSrcOperand
64204
64205         bool
64206         isDstOperand(int opIdx) override
64207         {
64208             switch (opIdx) {
64209               case 0: //vgpr_a
64210                 return false;
64211               case 1: //vgpr_d1
64212                 return false;
64213               case 2: //vgpr_rtn
64214                 return true;
64215               default:
64216                 fatal("op idx %i out of bounds\n", opIdx);
64217                 return false;
64218             }
64219         } // isDstOperand
64220
64221         void execute(GPUDynInstPtr) override;
64222     }; // Inst_DS__DS_WRXCHG2_RTN_B64
64223
64224     class Inst_DS__DS_WRXCHG2ST64_RTN_B64 : public Inst_DS
64225     {
64226       public:
64227         Inst_DS__DS_WRXCHG2ST64_RTN_B64(InFmt_DS*);
64228         ~Inst_DS__DS_WRXCHG2ST64_RTN_B64();
64229
64230         int
64231         getNumOperands() override
64232         {
64233             return numDstRegOperands() + numSrcRegOperands();
64234         } // getNumOperands
64235
64236         int numDstRegOperands() override { return 1; }
64237         int numSrcRegOperands() override { return 3; }
64238
64239         int
64240         getOperandSize(int opIdx) override
64241         {
64242             switch (opIdx) {
64243               case 0: //vgpr_a
64244                 return 4;
64245               case 1: //vgpr_d1
64246                 return 8;
64247               case 2: //vgpr_rtn
64248                 return 8;
64249               default:
64250                 fatal("op idx %i out of bounds\n", opIdx);
64251                 return -1;
64252             }
64253         } // getOperandSize
64254
64255         bool
64256         isSrcOperand(int opIdx) override
64257         {
64258             switch (opIdx) {
64259               case 0: //vgpr_a
64260                 return true;
64261               case 1: //vgpr_d1
64262                 return true;
64263               case 2: //vgpr_rtn
64264                 return false;
64265               default:
64266                 fatal("op idx %i out of bounds\n", opIdx);
64267                 return false;
64268             }
64269         } // isSrcOperand
64270
64271         bool
64272         isDstOperand(int opIdx) override
64273         {
64274             switch (opIdx) {
64275               case 0: //vgpr_a
64276                 return false;
64277               case 1: //vgpr_d1
64278                 return false;
64279               case 2: //vgpr_rtn
64280                 return true;
64281               default:
64282                 fatal("op idx %i out of bounds\n", opIdx);
64283                 return false;
64284             }
64285         } // isDstOperand
64286
64287         void execute(GPUDynInstPtr) override;
64288     }; // Inst_DS__DS_WRXCHG2ST64_RTN_B64
64289
64290     class Inst_DS__DS_CMPST_RTN_B64 : public Inst_DS
64291     {
64292       public:
64293         Inst_DS__DS_CMPST_RTN_B64(InFmt_DS*);
64294         ~Inst_DS__DS_CMPST_RTN_B64();
64295
64296         int
64297         getNumOperands() override
64298         {
64299             return numDstRegOperands() + numSrcRegOperands();
64300         } // getNumOperands
64301
64302         int numDstRegOperands() override { return 1; }
64303         int numSrcRegOperands() override { return 3; }
64304
64305         int
64306         getOperandSize(int opIdx) override
64307         {
64308             switch (opIdx) {
64309               case 0: //vgpr_a
64310                 return 4;
64311               case 1: //vgpr_d1
64312                 return 8;
64313               case 2: //vgpr_rtn
64314                 return 8;
64315               default:
64316                 fatal("op idx %i out of bounds\n", opIdx);
64317                 return -1;
64318             }
64319         } // getOperandSize
64320
64321         bool
64322         isSrcOperand(int opIdx) override
64323         {
64324             switch (opIdx) {
64325               case 0: //vgpr_a
64326                 return true;
64327               case 1: //vgpr_d1
64328                 return true;
64329               case 2: //vgpr_rtn
64330                 return false;
64331               default:
64332                 fatal("op idx %i out of bounds\n", opIdx);
64333                 return false;
64334             }
64335         } // isSrcOperand
64336
64337         bool
64338         isDstOperand(int opIdx) override
64339         {
64340             switch (opIdx) {
64341               case 0: //vgpr_a
64342                 return false;
64343               case 1: //vgpr_d1
64344                 return false;
64345               case 2: //vgpr_rtn
64346                 return true;
64347               default:
64348                 fatal("op idx %i out of bounds\n", opIdx);
64349                 return false;
64350             }
64351         } // isDstOperand
64352
64353         void execute(GPUDynInstPtr) override;
64354     }; // Inst_DS__DS_CMPST_RTN_B64
64355
64356     class Inst_DS__DS_CMPST_RTN_F64 : public Inst_DS
64357     {
64358       public:
64359         Inst_DS__DS_CMPST_RTN_F64(InFmt_DS*);
64360         ~Inst_DS__DS_CMPST_RTN_F64();
64361
64362         int
64363         getNumOperands() override
64364         {
64365             return numDstRegOperands() + numSrcRegOperands();
64366         } // getNumOperands
64367
64368         int numDstRegOperands() override { return 1; }
64369         int numSrcRegOperands() override { return 3; }
64370
64371         int
64372         getOperandSize(int opIdx) override
64373         {
64374             switch (opIdx) {
64375               case 0: //vgpr_a
64376                 return 4;
64377               case 1: //vgpr_d1
64378                 return 8;
64379               case 2: //vgpr_rtn
64380                 return 8;
64381               default:
64382                 fatal("op idx %i out of bounds\n", opIdx);
64383                 return -1;
64384             }
64385         } // getOperandSize
64386
64387         bool
64388         isSrcOperand(int opIdx) override
64389         {
64390             switch (opIdx) {
64391               case 0: //vgpr_a
64392                 return true;
64393               case 1: //vgpr_d1
64394                 return true;
64395               case 2: //vgpr_rtn
64396                 return false;
64397               default:
64398                 fatal("op idx %i out of bounds\n", opIdx);
64399                 return false;
64400             }
64401         } // isSrcOperand
64402
64403         bool
64404         isDstOperand(int opIdx) override
64405         {
64406             switch (opIdx) {
64407               case 0: //vgpr_a
64408                 return false;
64409               case 1: //vgpr_d1
64410                 return false;
64411               case 2: //vgpr_rtn
64412                 return true;
64413               default:
64414                 fatal("op idx %i out of bounds\n", opIdx);
64415                 return false;
64416             }
64417         } // isDstOperand
64418
64419         void execute(GPUDynInstPtr) override;
64420     }; // Inst_DS__DS_CMPST_RTN_F64
64421
64422     class Inst_DS__DS_MIN_RTN_F64 : public Inst_DS
64423     {
64424       public:
64425         Inst_DS__DS_MIN_RTN_F64(InFmt_DS*);
64426         ~Inst_DS__DS_MIN_RTN_F64();
64427
64428         int
64429         getNumOperands() override
64430         {
64431             return numDstRegOperands() + numSrcRegOperands();
64432         } // getNumOperands
64433
64434         int numDstRegOperands() override { return 1; }
64435         int numSrcRegOperands() override { return 2; }
64436
64437         int
64438         getOperandSize(int opIdx) override
64439         {
64440             switch (opIdx) {
64441               case 0: //vgpr_a
64442                 return 4;
64443               case 1: //vgpr_d0
64444                 return 8;
64445               case 2: //vgpr_rtn
64446                 return 8;
64447               default:
64448                 fatal("op idx %i out of bounds\n", opIdx);
64449                 return -1;
64450             }
64451         } // getOperandSize
64452
64453         bool
64454         isSrcOperand(int opIdx) override
64455         {
64456             switch (opIdx) {
64457               case 0: //vgpr_a
64458                 return true;
64459               case 1: //vgpr_d0
64460                 return true;
64461               case 2: //vgpr_rtn
64462                 return false;
64463               default:
64464                 fatal("op idx %i out of bounds\n", opIdx);
64465                 return false;
64466             }
64467         } // isSrcOperand
64468
64469         bool
64470         isDstOperand(int opIdx) override
64471         {
64472             switch (opIdx) {
64473               case 0: //vgpr_a
64474                 return false;
64475               case 1: //vgpr_d0
64476                 return false;
64477               case 2: //vgpr_rtn
64478                 return true;
64479               default:
64480                 fatal("op idx %i out of bounds\n", opIdx);
64481                 return false;
64482             }
64483         } // isDstOperand
64484
64485         void execute(GPUDynInstPtr) override;
64486     }; // Inst_DS__DS_MIN_RTN_F64
64487
64488     class Inst_DS__DS_MAX_RTN_F64 : public Inst_DS
64489     {
64490       public:
64491         Inst_DS__DS_MAX_RTN_F64(InFmt_DS*);
64492         ~Inst_DS__DS_MAX_RTN_F64();
64493
64494         int
64495         getNumOperands() override
64496         {
64497             return numDstRegOperands() + numSrcRegOperands();
64498         } // getNumOperands
64499
64500         int numDstRegOperands() override { return 1; }
64501         int numSrcRegOperands() override { return 2; }
64502
64503         int
64504         getOperandSize(int opIdx) override
64505         {
64506             switch (opIdx) {
64507               case 0: //vgpr_a
64508                 return 4;
64509               case 1: //vgpr_d0
64510                 return 8;
64511               case 2: //vgpr_rtn
64512                 return 8;
64513               default:
64514                 fatal("op idx %i out of bounds\n", opIdx);
64515                 return -1;
64516             }
64517         } // getOperandSize
64518
64519         bool
64520         isSrcOperand(int opIdx) override
64521         {
64522             switch (opIdx) {
64523               case 0: //vgpr_a
64524                 return true;
64525               case 1: //vgpr_d0
64526                 return true;
64527               case 2: //vgpr_rtn
64528                 return false;
64529               default:
64530                 fatal("op idx %i out of bounds\n", opIdx);
64531                 return false;
64532             }
64533         } // isSrcOperand
64534
64535         bool
64536         isDstOperand(int opIdx) override
64537         {
64538             switch (opIdx) {
64539               case 0: //vgpr_a
64540                 return false;
64541               case 1: //vgpr_d0
64542                 return false;
64543               case 2: //vgpr_rtn
64544                 return true;
64545               default:
64546                 fatal("op idx %i out of bounds\n", opIdx);
64547                 return false;
64548             }
64549         } // isDstOperand
64550
64551         void execute(GPUDynInstPtr) override;
64552     }; // Inst_DS__DS_MAX_RTN_F64
64553
64554     class Inst_DS__DS_READ_B64 : public Inst_DS
64555     {
64556       public:
64557         Inst_DS__DS_READ_B64(InFmt_DS*);
64558         ~Inst_DS__DS_READ_B64();
64559
64560         int
64561         getNumOperands() override
64562         {
64563             return numDstRegOperands() + numSrcRegOperands();
64564         } // getNumOperands
64565
64566         int numDstRegOperands() override { return 1; }
64567         int numSrcRegOperands() override { return 1; }
64568
64569         int
64570         getOperandSize(int opIdx) override
64571         {
64572             switch (opIdx) {
64573               case 0: //vgpr_a
64574                 return 4;
64575               case 1: //vgpr_rtn
64576                 return 8;
64577               default:
64578                 fatal("op idx %i out of bounds\n", opIdx);
64579                 return -1;
64580             }
64581         } // getOperandSize
64582
64583         bool
64584         isSrcOperand(int opIdx) override
64585         {
64586             switch (opIdx) {
64587               case 0: //vgpr_a
64588                 return true;
64589               case 1: //vgpr_rtn
64590                 return false;
64591               default:
64592                 fatal("op idx %i out of bounds\n", opIdx);
64593                 return false;
64594             }
64595         } // isSrcOperand
64596
64597         bool
64598         isDstOperand(int opIdx) override
64599         {
64600             switch (opIdx) {
64601               case 0: //vgpr_a
64602                 return false;
64603               case 1: //vgpr_rtn
64604                 return true;
64605               default:
64606                 fatal("op idx %i out of bounds\n", opIdx);
64607                 return false;
64608             }
64609         } // isDstOperand
64610
64611         void execute(GPUDynInstPtr) override;
64612         void initiateAcc(GPUDynInstPtr) override;
64613         void completeAcc(GPUDynInstPtr) override;
64614     }; // Inst_DS__DS_READ_B64
64615
64616     class Inst_DS__DS_READ2_B64 : public Inst_DS
64617     {
64618       public:
64619         Inst_DS__DS_READ2_B64(InFmt_DS*);
64620         ~Inst_DS__DS_READ2_B64();
64621
64622         int
64623         getNumOperands() override
64624         {
64625             return numDstRegOperands() + numSrcRegOperands();
64626         } // getNumOperands
64627
64628         int numDstRegOperands() override { return 1; }
64629         int numSrcRegOperands() override { return 1; }
64630
64631         int
64632         getOperandSize(int opIdx) override
64633         {
64634             switch (opIdx) {
64635               case 0: //vgpr_a
64636                 return 4;
64637               case 1: //vgpr_rtn
64638                 return 16;
64639               default:
64640                 fatal("op idx %i out of bounds\n", opIdx);
64641                 return -1;
64642             }
64643         } // getOperandSize
64644
64645         bool
64646         isSrcOperand(int opIdx) override
64647         {
64648             switch (opIdx) {
64649               case 0: //vgpr_a
64650                 return true;
64651               case 1: //vgpr_rtn
64652                 return false;
64653               default:
64654                 fatal("op idx %i out of bounds\n", opIdx);
64655                 return false;
64656             }
64657         } // isSrcOperand
64658
64659         bool
64660         isDstOperand(int opIdx) override
64661         {
64662             switch (opIdx) {
64663               case 0: //vgpr_a
64664                 return false;
64665               case 1: //vgpr_rtn
64666                 return true;
64667               default:
64668                 fatal("op idx %i out of bounds\n", opIdx);
64669                 return false;
64670             }
64671         } // isDstOperand
64672
64673         void execute(GPUDynInstPtr) override;
64674         void initiateAcc(GPUDynInstPtr) override;
64675         void completeAcc(GPUDynInstPtr) override;
64676     }; // Inst_DS__DS_READ2_B64
64677
64678     class Inst_DS__DS_READ2ST64_B64 : public Inst_DS
64679     {
64680       public:
64681         Inst_DS__DS_READ2ST64_B64(InFmt_DS*);
64682         ~Inst_DS__DS_READ2ST64_B64();
64683
64684         int
64685         getNumOperands() override
64686         {
64687             return numDstRegOperands() + numSrcRegOperands();
64688         } // getNumOperands
64689
64690         int numDstRegOperands() override { return 1; }
64691         int numSrcRegOperands() override { return 1; }
64692
64693         int
64694         getOperandSize(int opIdx) override
64695         {
64696             switch (opIdx) {
64697               case 0: //vgpr_a
64698                 return 4;
64699               case 1: //vgpr_rtn
64700                 return 8;
64701               default:
64702                 fatal("op idx %i out of bounds\n", opIdx);
64703                 return -1;
64704             }
64705         } // getOperandSize
64706
64707         bool
64708         isSrcOperand(int opIdx) override
64709         {
64710             switch (opIdx) {
64711               case 0: //vgpr_a
64712                 return true;
64713               case 1: //vgpr_rtn
64714                 return false;
64715               default:
64716                 fatal("op idx %i out of bounds\n", opIdx);
64717                 return false;
64718             }
64719         } // isSrcOperand
64720
64721         bool
64722         isDstOperand(int opIdx) override
64723         {
64724             switch (opIdx) {
64725               case 0: //vgpr_a
64726                 return false;
64727               case 1: //vgpr_rtn
64728                 return true;
64729               default:
64730                 fatal("op idx %i out of bounds\n", opIdx);
64731                 return false;
64732             }
64733         } // isDstOperand
64734
64735         void execute(GPUDynInstPtr) override;
64736         void initiateAcc(GPUDynInstPtr) override;
64737         void completeAcc(GPUDynInstPtr) override;
64738     }; // Inst_DS__DS_READ2ST64_B64
64739
64740     class Inst_DS__DS_CONDXCHG32_RTN_B64 : public Inst_DS
64741     {
64742       public:
64743         Inst_DS__DS_CONDXCHG32_RTN_B64(InFmt_DS*);
64744         ~Inst_DS__DS_CONDXCHG32_RTN_B64();
64745
64746         int
64747         getNumOperands() override
64748         {
64749             return numDstRegOperands() + numSrcRegOperands();
64750         } // getNumOperands
64751
64752         int numDstRegOperands() override { return 1; }
64753         int numSrcRegOperands() override { return 2; }
64754
64755         int
64756         getOperandSize(int opIdx) override
64757         {
64758             switch (opIdx) {
64759               case 0: //vgpr_a
64760                 return 4;
64761               case 1: //vgpr_d0
64762                 return 8;
64763               case 2: //vgpr_rtn
64764                 return 8;
64765               default:
64766                 fatal("op idx %i out of bounds\n", opIdx);
64767                 return -1;
64768             }
64769         } // getOperandSize
64770
64771         bool
64772         isSrcOperand(int opIdx) override
64773         {
64774             switch (opIdx) {
64775               case 0: //vgpr_a
64776                 return true;
64777               case 1: //vgpr_d0
64778                 return true;
64779               case 2: //vgpr_rtn
64780                 return false;
64781               default:
64782                 fatal("op idx %i out of bounds\n", opIdx);
64783                 return false;
64784             }
64785         } // isSrcOperand
64786
64787         bool
64788         isDstOperand(int opIdx) override
64789         {
64790             switch (opIdx) {
64791               case 0: //vgpr_a
64792                 return false;
64793               case 1: //vgpr_d0
64794                 return false;
64795               case 2: //vgpr_rtn
64796                 return true;
64797               default:
64798                 fatal("op idx %i out of bounds\n", opIdx);
64799                 return false;
64800             }
64801         } // isDstOperand
64802
64803         void execute(GPUDynInstPtr) override;
64804     }; // Inst_DS__DS_CONDXCHG32_RTN_B64
64805
64806     class Inst_DS__DS_ADD_SRC2_U32 : public Inst_DS
64807     {
64808       public:
64809         Inst_DS__DS_ADD_SRC2_U32(InFmt_DS*);
64810         ~Inst_DS__DS_ADD_SRC2_U32();
64811
64812         int
64813         getNumOperands() override
64814         {
64815             return numDstRegOperands() + numSrcRegOperands();
64816         } // getNumOperands
64817
64818         int numDstRegOperands() override { return 0; }
64819         int numSrcRegOperands() override { return 1; }
64820
64821         int
64822         getOperandSize(int opIdx) override
64823         {
64824             switch (opIdx) {
64825               case 0: //vgpr_a
64826                 return 4;
64827               default:
64828                 fatal("op idx %i out of bounds\n", opIdx);
64829                 return -1;
64830             }
64831         } // getOperandSize
64832
64833         bool
64834         isSrcOperand(int opIdx) override
64835         {
64836             switch (opIdx) {
64837               case 0: //vgpr_a
64838                 return true;
64839               default:
64840                 fatal("op idx %i out of bounds\n", opIdx);
64841                 return false;
64842             }
64843         } // isSrcOperand
64844
64845         bool
64846         isDstOperand(int opIdx) override
64847         {
64848             switch (opIdx) {
64849               case 0: //vgpr_a
64850                 return false;
64851               default:
64852                 fatal("op idx %i out of bounds\n", opIdx);
64853                 return false;
64854             }
64855         } // isDstOperand
64856
64857         void execute(GPUDynInstPtr) override;
64858     }; // Inst_DS__DS_ADD_SRC2_U32
64859
64860     class Inst_DS__DS_SUB_SRC2_U32 : public Inst_DS
64861     {
64862       public:
64863         Inst_DS__DS_SUB_SRC2_U32(InFmt_DS*);
64864         ~Inst_DS__DS_SUB_SRC2_U32();
64865
64866         int
64867         getNumOperands() override
64868         {
64869             return numDstRegOperands() + numSrcRegOperands();
64870         } // getNumOperands
64871
64872         int numDstRegOperands() override { return 0; }
64873         int numSrcRegOperands() override { return 1; }
64874
64875         int
64876         getOperandSize(int opIdx) override
64877         {
64878             switch (opIdx) {
64879               case 0: //vgpr_a
64880                 return 4;
64881               default:
64882                 fatal("op idx %i out of bounds\n", opIdx);
64883                 return -1;
64884             }
64885         } // getOperandSize
64886
64887         bool
64888         isSrcOperand(int opIdx) override
64889         {
64890             switch (opIdx) {
64891               case 0: //vgpr_a
64892                 return true;
64893               default:
64894                 fatal("op idx %i out of bounds\n", opIdx);
64895                 return false;
64896             }
64897         } // isSrcOperand
64898
64899         bool
64900         isDstOperand(int opIdx) override
64901         {
64902             switch (opIdx) {
64903               case 0: //vgpr_a
64904                 return false;
64905               default:
64906                 fatal("op idx %i out of bounds\n", opIdx);
64907                 return false;
64908             }
64909         } // isDstOperand
64910
64911         void execute(GPUDynInstPtr) override;
64912     }; // Inst_DS__DS_SUB_SRC2_U32
64913
64914     class Inst_DS__DS_RSUB_SRC2_U32 : public Inst_DS
64915     {
64916       public:
64917         Inst_DS__DS_RSUB_SRC2_U32(InFmt_DS*);
64918         ~Inst_DS__DS_RSUB_SRC2_U32();
64919
64920         int
64921         getNumOperands() override
64922         {
64923             return numDstRegOperands() + numSrcRegOperands();
64924         } // getNumOperands
64925
64926         int numDstRegOperands() override { return 0; }
64927         int numSrcRegOperands() override { return 1; }
64928
64929         int
64930         getOperandSize(int opIdx) override
64931         {
64932             switch (opIdx) {
64933               case 0: //vgpr_a
64934                 return 4;
64935               default:
64936                 fatal("op idx %i out of bounds\n", opIdx);
64937                 return -1;
64938             }
64939         } // getOperandSize
64940
64941         bool
64942         isSrcOperand(int opIdx) override
64943         {
64944             switch (opIdx) {
64945               case 0: //vgpr_a
64946                 return true;
64947               default:
64948                 fatal("op idx %i out of bounds\n", opIdx);
64949                 return false;
64950             }
64951         } // isSrcOperand
64952
64953         bool
64954         isDstOperand(int opIdx) override
64955         {
64956             switch (opIdx) {
64957               case 0: //vgpr_a
64958                 return false;
64959               default:
64960                 fatal("op idx %i out of bounds\n", opIdx);
64961                 return false;
64962             }
64963         } // isDstOperand
64964
64965         void execute(GPUDynInstPtr) override;
64966     }; // Inst_DS__DS_RSUB_SRC2_U32
64967
64968     class Inst_DS__DS_INC_SRC2_U32 : public Inst_DS
64969     {
64970       public:
64971         Inst_DS__DS_INC_SRC2_U32(InFmt_DS*);
64972         ~Inst_DS__DS_INC_SRC2_U32();
64973
64974         int
64975         getNumOperands() override
64976         {
64977             return numDstRegOperands() + numSrcRegOperands();
64978         } // getNumOperands
64979
64980         int numDstRegOperands() override { return 0; }
64981         int numSrcRegOperands() override { return 1; }
64982
64983         int
64984         getOperandSize(int opIdx) override
64985         {
64986             switch (opIdx) {
64987               case 0: //vgpr_a
64988                 return 4;
64989               default:
64990                 fatal("op idx %i out of bounds\n", opIdx);
64991                 return -1;
64992             }
64993         } // getOperandSize
64994
64995         bool
64996         isSrcOperand(int opIdx) override
64997         {
64998             switch (opIdx) {
64999               case 0: //vgpr_a
65000                 return true;
65001               default:
65002                 fatal("op idx %i out of bounds\n", opIdx);
65003                 return false;
65004             }
65005         } // isSrcOperand
65006
65007         bool
65008         isDstOperand(int opIdx) override
65009         {
65010             switch (opIdx) {
65011               case 0: //vgpr_a
65012                 return false;
65013               default:
65014                 fatal("op idx %i out of bounds\n", opIdx);
65015                 return false;
65016             }
65017         } // isDstOperand
65018
65019         void execute(GPUDynInstPtr) override;
65020     }; // Inst_DS__DS_INC_SRC2_U32
65021
65022     class Inst_DS__DS_DEC_SRC2_U32 : public Inst_DS
65023     {
65024       public:
65025         Inst_DS__DS_DEC_SRC2_U32(InFmt_DS*);
65026         ~Inst_DS__DS_DEC_SRC2_U32();
65027
65028         int
65029         getNumOperands() override
65030         {
65031             return numDstRegOperands() + numSrcRegOperands();
65032         } // getNumOperands
65033
65034         int numDstRegOperands() override { return 0; }
65035         int numSrcRegOperands() override { return 1; }
65036
65037         int
65038         getOperandSize(int opIdx) override
65039         {
65040             switch (opIdx) {
65041               case 0: //vgpr_a
65042                 return 4;
65043               default:
65044                 fatal("op idx %i out of bounds\n", opIdx);
65045                 return -1;
65046             }
65047         } // getOperandSize
65048
65049         bool
65050         isSrcOperand(int opIdx) override
65051         {
65052             switch (opIdx) {
65053               case 0: //vgpr_a
65054                 return true;
65055               default:
65056                 fatal("op idx %i out of bounds\n", opIdx);
65057                 return false;
65058             }
65059         } // isSrcOperand
65060
65061         bool
65062         isDstOperand(int opIdx) override
65063         {
65064             switch (opIdx) {
65065               case 0: //vgpr_a
65066                 return false;
65067               default:
65068                 fatal("op idx %i out of bounds\n", opIdx);
65069                 return false;
65070             }
65071         } // isDstOperand
65072
65073         void execute(GPUDynInstPtr) override;
65074     }; // Inst_DS__DS_DEC_SRC2_U32
65075
65076     class Inst_DS__DS_MIN_SRC2_I32 : public Inst_DS
65077     {
65078       public:
65079         Inst_DS__DS_MIN_SRC2_I32(InFmt_DS*);
65080         ~Inst_DS__DS_MIN_SRC2_I32();
65081
65082         int
65083         getNumOperands() override
65084         {
65085             return numDstRegOperands() + numSrcRegOperands();
65086         } // getNumOperands
65087
65088         int numDstRegOperands() override { return 0; }
65089         int numSrcRegOperands() override { return 1; }
65090
65091         int
65092         getOperandSize(int opIdx) override
65093         {
65094             switch (opIdx) {
65095               case 0: //vgpr_a
65096                 return 4;
65097               default:
65098                 fatal("op idx %i out of bounds\n", opIdx);
65099                 return -1;
65100             }
65101         } // getOperandSize
65102
65103         bool
65104         isSrcOperand(int opIdx) override
65105         {
65106             switch (opIdx) {
65107               case 0: //vgpr_a
65108                 return true;
65109               default:
65110                 fatal("op idx %i out of bounds\n", opIdx);
65111                 return false;
65112             }
65113         } // isSrcOperand
65114
65115         bool
65116         isDstOperand(int opIdx) override
65117         {
65118             switch (opIdx) {
65119               case 0: //vgpr_a
65120                 return false;
65121               default:
65122                 fatal("op idx %i out of bounds\n", opIdx);
65123                 return false;
65124             }
65125         } // isDstOperand
65126
65127         void execute(GPUDynInstPtr) override;
65128     }; // Inst_DS__DS_MIN_SRC2_I32
65129
65130     class Inst_DS__DS_MAX_SRC2_I32 : public Inst_DS
65131     {
65132       public:
65133         Inst_DS__DS_MAX_SRC2_I32(InFmt_DS*);
65134         ~Inst_DS__DS_MAX_SRC2_I32();
65135
65136         int
65137         getNumOperands() override
65138         {
65139             return numDstRegOperands() + numSrcRegOperands();
65140         } // getNumOperands
65141
65142         int numDstRegOperands() override { return 0; }
65143         int numSrcRegOperands() override { return 1; }
65144
65145         int
65146         getOperandSize(int opIdx) override
65147         {
65148             switch (opIdx) {
65149               case 0: //vgpr_a
65150                 return 4;
65151               default:
65152                 fatal("op idx %i out of bounds\n", opIdx);
65153                 return -1;
65154             }
65155         } // getOperandSize
65156
65157         bool
65158         isSrcOperand(int opIdx) override
65159         {
65160             switch (opIdx) {
65161               case 0: //vgpr_a
65162                 return true;
65163               default:
65164                 fatal("op idx %i out of bounds\n", opIdx);
65165                 return false;
65166             }
65167         } // isSrcOperand
65168
65169         bool
65170         isDstOperand(int opIdx) override
65171         {
65172             switch (opIdx) {
65173               case 0: //vgpr_a
65174                 return false;
65175               default:
65176                 fatal("op idx %i out of bounds\n", opIdx);
65177                 return false;
65178             }
65179         } // isDstOperand
65180
65181         void execute(GPUDynInstPtr) override;
65182     }; // Inst_DS__DS_MAX_SRC2_I32
65183
65184     class Inst_DS__DS_MIN_SRC2_U32 : public Inst_DS
65185     {
65186       public:
65187         Inst_DS__DS_MIN_SRC2_U32(InFmt_DS*);
65188         ~Inst_DS__DS_MIN_SRC2_U32();
65189
65190         int
65191         getNumOperands() override
65192         {
65193             return numDstRegOperands() + numSrcRegOperands();
65194         } // getNumOperands
65195
65196         int numDstRegOperands() override { return 0; }
65197         int numSrcRegOperands() override { return 1; }
65198
65199         int
65200         getOperandSize(int opIdx) override
65201         {
65202             switch (opIdx) {
65203               case 0: //vgpr_a
65204                 return 4;
65205               default:
65206                 fatal("op idx %i out of bounds\n", opIdx);
65207                 return -1;
65208             }
65209         } // getOperandSize
65210
65211         bool
65212         isSrcOperand(int opIdx) override
65213         {
65214             switch (opIdx) {
65215               case 0: //vgpr_a
65216                 return true;
65217               default:
65218                 fatal("op idx %i out of bounds\n", opIdx);
65219                 return false;
65220             }
65221         } // isSrcOperand
65222
65223         bool
65224         isDstOperand(int opIdx) override
65225         {
65226             switch (opIdx) {
65227               case 0: //vgpr_a
65228                 return false;
65229               default:
65230                 fatal("op idx %i out of bounds\n", opIdx);
65231                 return false;
65232             }
65233         } // isDstOperand
65234
65235         void execute(GPUDynInstPtr) override;
65236     }; // Inst_DS__DS_MIN_SRC2_U32
65237
65238     class Inst_DS__DS_MAX_SRC2_U32 : public Inst_DS
65239     {
65240       public:
65241         Inst_DS__DS_MAX_SRC2_U32(InFmt_DS*);
65242         ~Inst_DS__DS_MAX_SRC2_U32();
65243
65244         int
65245         getNumOperands() override
65246         {
65247             return numDstRegOperands() + numSrcRegOperands();
65248         } // getNumOperands
65249
65250         int numDstRegOperands() override { return 0; }
65251         int numSrcRegOperands() override { return 1; }
65252
65253         int
65254         getOperandSize(int opIdx) override
65255         {
65256             switch (opIdx) {
65257               case 0: //vgpr_a
65258                 return 4;
65259               default:
65260                 fatal("op idx %i out of bounds\n", opIdx);
65261                 return -1;
65262             }
65263         } // getOperandSize
65264
65265         bool
65266         isSrcOperand(int opIdx) override
65267         {
65268             switch (opIdx) {
65269               case 0: //vgpr_a
65270                 return true;
65271               default:
65272                 fatal("op idx %i out of bounds\n", opIdx);
65273                 return false;
65274             }
65275         } // isSrcOperand
65276
65277         bool
65278         isDstOperand(int opIdx) override
65279         {
65280             switch (opIdx) {
65281               case 0: //vgpr_a
65282                 return false;
65283               default:
65284                 fatal("op idx %i out of bounds\n", opIdx);
65285                 return false;
65286             }
65287         } // isDstOperand
65288
65289         void execute(GPUDynInstPtr) override;
65290     }; // Inst_DS__DS_MAX_SRC2_U32
65291
65292     class Inst_DS__DS_AND_SRC2_B32 : public Inst_DS
65293     {
65294       public:
65295         Inst_DS__DS_AND_SRC2_B32(InFmt_DS*);
65296         ~Inst_DS__DS_AND_SRC2_B32();
65297
65298         int
65299         getNumOperands() override
65300         {
65301             return numDstRegOperands() + numSrcRegOperands();
65302         } // getNumOperands
65303
65304         int numDstRegOperands() override { return 0; }
65305         int numSrcRegOperands() override { return 1; }
65306
65307         int
65308         getOperandSize(int opIdx) override
65309         {
65310             switch (opIdx) {
65311               case 0: //vgpr_a
65312                 return 4;
65313               default:
65314                 fatal("op idx %i out of bounds\n", opIdx);
65315                 return -1;
65316             }
65317         } // getOperandSize
65318
65319         bool
65320         isSrcOperand(int opIdx) override
65321         {
65322             switch (opIdx) {
65323               case 0: //vgpr_a
65324                 return true;
65325               default:
65326                 fatal("op idx %i out of bounds\n", opIdx);
65327                 return false;
65328             }
65329         } // isSrcOperand
65330
65331         bool
65332         isDstOperand(int opIdx) override
65333         {
65334             switch (opIdx) {
65335               case 0: //vgpr_a
65336                 return false;
65337               default:
65338                 fatal("op idx %i out of bounds\n", opIdx);
65339                 return false;
65340             }
65341         } // isDstOperand
65342
65343         void execute(GPUDynInstPtr) override;
65344     }; // Inst_DS__DS_AND_SRC2_B32
65345
65346     class Inst_DS__DS_OR_SRC2_B32 : public Inst_DS
65347     {
65348       public:
65349         Inst_DS__DS_OR_SRC2_B32(InFmt_DS*);
65350         ~Inst_DS__DS_OR_SRC2_B32();
65351
65352         int
65353         getNumOperands() override
65354         {
65355             return numDstRegOperands() + numSrcRegOperands();
65356         } // getNumOperands
65357
65358         int numDstRegOperands() override { return 0; }
65359         int numSrcRegOperands() override { return 1; }
65360
65361         int
65362         getOperandSize(int opIdx) override
65363         {
65364             switch (opIdx) {
65365               case 0: //vgpr_a
65366                 return 4;
65367               default:
65368                 fatal("op idx %i out of bounds\n", opIdx);
65369                 return -1;
65370             }
65371         } // getOperandSize
65372
65373         bool
65374         isSrcOperand(int opIdx) override
65375         {
65376             switch (opIdx) {
65377               case 0: //vgpr_a
65378                 return true;
65379               default:
65380                 fatal("op idx %i out of bounds\n", opIdx);
65381                 return false;
65382             }
65383         } // isSrcOperand
65384
65385         bool
65386         isDstOperand(int opIdx) override
65387         {
65388             switch (opIdx) {
65389               case 0: //vgpr_a
65390                 return false;
65391               default:
65392                 fatal("op idx %i out of bounds\n", opIdx);
65393                 return false;
65394             }
65395         } // isDstOperand
65396
65397         void execute(GPUDynInstPtr) override;
65398     }; // Inst_DS__DS_OR_SRC2_B32
65399
65400     class Inst_DS__DS_XOR_SRC2_B32 : public Inst_DS
65401     {
65402       public:
65403         Inst_DS__DS_XOR_SRC2_B32(InFmt_DS*);
65404         ~Inst_DS__DS_XOR_SRC2_B32();
65405
65406         int
65407         getNumOperands() override
65408         {
65409             return numDstRegOperands() + numSrcRegOperands();
65410         } // getNumOperands
65411
65412         int numDstRegOperands() override { return 0; }
65413         int numSrcRegOperands() override { return 1; }
65414
65415         int
65416         getOperandSize(int opIdx) override
65417         {
65418             switch (opIdx) {
65419               case 0: //vgpr_a
65420                 return 4;
65421               default:
65422                 fatal("op idx %i out of bounds\n", opIdx);
65423                 return -1;
65424             }
65425         } // getOperandSize
65426
65427         bool
65428         isSrcOperand(int opIdx) override
65429         {
65430             switch (opIdx) {
65431               case 0: //vgpr_a
65432                 return true;
65433               default:
65434                 fatal("op idx %i out of bounds\n", opIdx);
65435                 return false;
65436             }
65437         } // isSrcOperand
65438
65439         bool
65440         isDstOperand(int opIdx) override
65441         {
65442             switch (opIdx) {
65443               case 0: //vgpr_a
65444                 return false;
65445               default:
65446                 fatal("op idx %i out of bounds\n", opIdx);
65447                 return false;
65448             }
65449         } // isDstOperand
65450
65451         void execute(GPUDynInstPtr) override;
65452     }; // Inst_DS__DS_XOR_SRC2_B32
65453
65454     class Inst_DS__DS_WRITE_SRC2_B32 : public Inst_DS
65455     {
65456       public:
65457         Inst_DS__DS_WRITE_SRC2_B32(InFmt_DS*);
65458         ~Inst_DS__DS_WRITE_SRC2_B32();
65459
65460         int
65461         getNumOperands() override
65462         {
65463             return numDstRegOperands() + numSrcRegOperands();
65464         } // getNumOperands
65465
65466         int numDstRegOperands() override { return 0; }
65467         int numSrcRegOperands() override { return 1; }
65468
65469         int
65470         getOperandSize(int opIdx) override
65471         {
65472             switch (opIdx) {
65473               case 0: //vgpr_a
65474                 return 4;
65475               default:
65476                 fatal("op idx %i out of bounds\n", opIdx);
65477                 return -1;
65478             }
65479         } // getOperandSize
65480
65481         bool
65482         isSrcOperand(int opIdx) override
65483         {
65484             switch (opIdx) {
65485               case 0: //vgpr_a
65486                 return true;
65487               default:
65488                 fatal("op idx %i out of bounds\n", opIdx);
65489                 return false;
65490             }
65491         } // isSrcOperand
65492
65493         bool
65494         isDstOperand(int opIdx) override
65495         {
65496             switch (opIdx) {
65497               case 0: //vgpr_a
65498                 return false;
65499               default:
65500                 fatal("op idx %i out of bounds\n", opIdx);
65501                 return false;
65502             }
65503         } // isDstOperand
65504
65505         void execute(GPUDynInstPtr) override;
65506     }; // Inst_DS__DS_WRITE_SRC2_B32
65507
65508     class Inst_DS__DS_MIN_SRC2_F32 : public Inst_DS
65509     {
65510       public:
65511         Inst_DS__DS_MIN_SRC2_F32(InFmt_DS*);
65512         ~Inst_DS__DS_MIN_SRC2_F32();
65513
65514         int
65515         getNumOperands() override
65516         {
65517             return numDstRegOperands() + numSrcRegOperands();
65518         } // getNumOperands
65519
65520         int numDstRegOperands() override { return 0; }
65521         int numSrcRegOperands() override { return 1; }
65522
65523         int
65524         getOperandSize(int opIdx) override
65525         {
65526             switch (opIdx) {
65527               case 0: //vgpr_a
65528                 return 4;
65529               default:
65530                 fatal("op idx %i out of bounds\n", opIdx);
65531                 return -1;
65532             }
65533         } // getOperandSize
65534
65535         bool
65536         isSrcOperand(int opIdx) override
65537         {
65538             switch (opIdx) {
65539               case 0: //vgpr_a
65540                 return true;
65541               default:
65542                 fatal("op idx %i out of bounds\n", opIdx);
65543                 return false;
65544             }
65545         } // isSrcOperand
65546
65547         bool
65548         isDstOperand(int opIdx) override
65549         {
65550             switch (opIdx) {
65551               case 0: //vgpr_a
65552                 return false;
65553               default:
65554                 fatal("op idx %i out of bounds\n", opIdx);
65555                 return false;
65556             }
65557         } // isDstOperand
65558
65559         void execute(GPUDynInstPtr) override;
65560     }; // Inst_DS__DS_MIN_SRC2_F32
65561
65562     class Inst_DS__DS_MAX_SRC2_F32 : public Inst_DS
65563     {
65564       public:
65565         Inst_DS__DS_MAX_SRC2_F32(InFmt_DS*);
65566         ~Inst_DS__DS_MAX_SRC2_F32();
65567
65568         int
65569         getNumOperands() override
65570         {
65571             return numDstRegOperands() + numSrcRegOperands();
65572         } // getNumOperands
65573
65574         int numDstRegOperands() override { return 0; }
65575         int numSrcRegOperands() override { return 1; }
65576
65577         int
65578         getOperandSize(int opIdx) override
65579         {
65580             switch (opIdx) {
65581               case 0: //vgpr_a
65582                 return 4;
65583               default:
65584                 fatal("op idx %i out of bounds\n", opIdx);
65585                 return -1;
65586             }
65587         } // getOperandSize
65588
65589         bool
65590         isSrcOperand(int opIdx) override
65591         {
65592             switch (opIdx) {
65593               case 0: //vgpr_a
65594                 return true;
65595               default:
65596                 fatal("op idx %i out of bounds\n", opIdx);
65597                 return false;
65598             }
65599         } // isSrcOperand
65600
65601         bool
65602         isDstOperand(int opIdx) override
65603         {
65604             switch (opIdx) {
65605               case 0: //vgpr_a
65606                 return false;
65607               default:
65608                 fatal("op idx %i out of bounds\n", opIdx);
65609                 return false;
65610             }
65611         } // isDstOperand
65612
65613         void execute(GPUDynInstPtr) override;
65614     }; // Inst_DS__DS_MAX_SRC2_F32
65615
65616     class Inst_DS__DS_ADD_SRC2_F32 : public Inst_DS
65617     {
65618       public:
65619         Inst_DS__DS_ADD_SRC2_F32(InFmt_DS*);
65620         ~Inst_DS__DS_ADD_SRC2_F32();
65621
65622         int
65623         getNumOperands() override
65624         {
65625             return numDstRegOperands() + numSrcRegOperands();
65626         } // getNumOperands
65627
65628         int numDstRegOperands() override { return 0; }
65629         int numSrcRegOperands() override { return 1; }
65630
65631         int
65632         getOperandSize(int opIdx) override
65633         {
65634             switch (opIdx) {
65635               case 0: //vgpr_a
65636                 return 4;
65637               default:
65638                 fatal("op idx %i out of bounds\n", opIdx);
65639                 return -1;
65640             }
65641         } // getOperandSize
65642
65643         bool
65644         isSrcOperand(int opIdx) override
65645         {
65646             switch (opIdx) {
65647               case 0: //vgpr_a
65648                 return true;
65649               default:
65650                 fatal("op idx %i out of bounds\n", opIdx);
65651                 return false;
65652             }
65653         } // isSrcOperand
65654
65655         bool
65656         isDstOperand(int opIdx) override
65657         {
65658             switch (opIdx) {
65659               case 0: //vgpr_a
65660                 return false;
65661               default:
65662                 fatal("op idx %i out of bounds\n", opIdx);
65663                 return false;
65664             }
65665         } // isDstOperand
65666
65667         void execute(GPUDynInstPtr) override;
65668     }; // Inst_DS__DS_ADD_SRC2_F32
65669
65670     class Inst_DS__DS_GWS_SEMA_RELEASE_ALL : public Inst_DS
65671     {
65672       public:
65673         Inst_DS__DS_GWS_SEMA_RELEASE_ALL(InFmt_DS*);
65674         ~Inst_DS__DS_GWS_SEMA_RELEASE_ALL();
65675
65676         int
65677         getNumOperands() override
65678         {
65679             return numDstRegOperands() + numSrcRegOperands();
65680         } // getNumOperands
65681
65682         int numDstRegOperands() override { return 0; }
65683         int numSrcRegOperands() override { return 0; }
65684
65685         int
65686         getOperandSize(int opIdx) override
65687         {
65688             switch (opIdx) {
65689               case 0: //vgpr_a
65690                 return 4;
65691               default:
65692                 fatal("op idx %i out of bounds\n", opIdx);
65693                 return -1;
65694             }
65695         } // getOperandSize
65696
65697         bool
65698         isSrcOperand(int opIdx) override
65699         {
65700             switch (opIdx) {
65701               case 0: //vgpr_a
65702                 return true;
65703               default:
65704                 fatal("op idx %i out of bounds\n", opIdx);
65705                 return false;
65706             }
65707         } // isSrcOperand
65708
65709         bool
65710         isDstOperand(int opIdx) override
65711         {
65712             switch (opIdx) {
65713               case 0: //vgpr_a
65714                 return false;
65715               default:
65716                 fatal("op idx %i out of bounds\n", opIdx);
65717                 return false;
65718             }
65719         } // isDstOperand
65720
65721         void execute(GPUDynInstPtr) override;
65722     }; // Inst_DS__DS_GWS_SEMA_RELEASE_ALL
65723
65724     class Inst_DS__DS_GWS_INIT : public Inst_DS
65725     {
65726       public:
65727         Inst_DS__DS_GWS_INIT(InFmt_DS*);
65728         ~Inst_DS__DS_GWS_INIT();
65729
65730         int
65731         getNumOperands() override
65732         {
65733             return numDstRegOperands() + numSrcRegOperands();
65734         } // getNumOperands
65735
65736         int numDstRegOperands() override { return 0; }
65737         int numSrcRegOperands() override { return 1; }
65738
65739         int
65740         getOperandSize(int opIdx) override
65741         {
65742             switch (opIdx) {
65743               case 0: //vgpr_d0
65744                 return 4;
65745               case 1: //vgpr_d0
65746                 return 4;
65747               default:
65748                 fatal("op idx %i out of bounds\n", opIdx);
65749                 return -1;
65750             }
65751         } // getOperandSize
65752
65753         bool
65754         isSrcOperand(int opIdx) override
65755         {
65756             switch (opIdx) {
65757               case 0: //vgpr_d0
65758                 return true;
65759               case 1: //vgpr_d0
65760                 return true;
65761               default:
65762                 fatal("op idx %i out of bounds\n", opIdx);
65763                 return false;
65764             }
65765         } // isSrcOperand
65766
65767         bool
65768         isDstOperand(int opIdx) override
65769         {
65770             switch (opIdx) {
65771               case 0: //vgpr_d0
65772                 return false;
65773               case 1: //vgpr_d0
65774                 return false;
65775               default:
65776                 fatal("op idx %i out of bounds\n", opIdx);
65777                 return false;
65778             }
65779         } // isDstOperand
65780
65781         void execute(GPUDynInstPtr) override;
65782     }; // Inst_DS__DS_GWS_INIT
65783
65784     class Inst_DS__DS_GWS_SEMA_V : public Inst_DS
65785     {
65786       public:
65787         Inst_DS__DS_GWS_SEMA_V(InFmt_DS*);
65788         ~Inst_DS__DS_GWS_SEMA_V();
65789
65790         int
65791         getNumOperands() override
65792         {
65793             return numDstRegOperands() + numSrcRegOperands();
65794         } // getNumOperands
65795
65796         int numDstRegOperands() override { return 0; }
65797         int numSrcRegOperands() override { return 0; }
65798
65799         int
65800         getOperandSize(int opIdx) override
65801         {
65802             switch (opIdx) {
65803               case 0: //vgpr_a
65804                 return 4;
65805               default:
65806                 fatal("op idx %i out of bounds\n", opIdx);
65807                 return -1;
65808             }
65809         } // getOperandSize
65810
65811         bool
65812         isSrcOperand(int opIdx) override
65813         {
65814             switch (opIdx) {
65815               case 0: //vgpr_a
65816                 return true;
65817               default:
65818                 fatal("op idx %i out of bounds\n", opIdx);
65819                 return false;
65820             }
65821         } // isSrcOperand
65822
65823         bool
65824         isDstOperand(int opIdx) override
65825         {
65826             switch (opIdx) {
65827               case 0: //vgpr_a
65828                 return false;
65829               default:
65830                 fatal("op idx %i out of bounds\n", opIdx);
65831                 return false;
65832             }
65833         } // isDstOperand
65834
65835         void execute(GPUDynInstPtr) override;
65836     }; // Inst_DS__DS_GWS_SEMA_V
65837
65838     class Inst_DS__DS_GWS_SEMA_BR : public Inst_DS
65839     {
65840       public:
65841         Inst_DS__DS_GWS_SEMA_BR(InFmt_DS*);
65842         ~Inst_DS__DS_GWS_SEMA_BR();
65843
65844         int
65845         getNumOperands() override
65846         {
65847             return numDstRegOperands() + numSrcRegOperands();
65848         } // getNumOperands
65849
65850         int numDstRegOperands() override { return 0; }
65851         int numSrcRegOperands() override { return 1; }
65852
65853         int
65854         getOperandSize(int opIdx) override
65855         {
65856             switch (opIdx) {
65857               case 0: //vgpr_d0
65858                 return 4;
65859               case 1: //vgpr_d0
65860                 return 4;
65861               default:
65862                 fatal("op idx %i out of bounds\n", opIdx);
65863                 return -1;
65864             }
65865         } // getOperandSize
65866
65867         bool
65868         isSrcOperand(int opIdx) override
65869         {
65870             switch (opIdx) {
65871               case 0: //vgpr_d0
65872                 return true;
65873               case 1: //vgpr_d0
65874                 return true;
65875               default:
65876                 fatal("op idx %i out of bounds\n", opIdx);
65877                 return false;
65878             }
65879         } // isSrcOperand
65880
65881         bool
65882         isDstOperand(int opIdx) override
65883         {
65884             switch (opIdx) {
65885               case 0: //vgpr_d0
65886                 return false;
65887               case 1: //vgpr_d0
65888                 return false;
65889               default:
65890                 fatal("op idx %i out of bounds\n", opIdx);
65891                 return false;
65892             }
65893         } // isDstOperand
65894
65895         void execute(GPUDynInstPtr) override;
65896     }; // Inst_DS__DS_GWS_SEMA_BR
65897
65898     class Inst_DS__DS_GWS_SEMA_P : public Inst_DS
65899     {
65900       public:
65901         Inst_DS__DS_GWS_SEMA_P(InFmt_DS*);
65902         ~Inst_DS__DS_GWS_SEMA_P();
65903
65904         int
65905         getNumOperands() override
65906         {
65907             return numDstRegOperands() + numSrcRegOperands();
65908         } // getNumOperands
65909
65910         int numDstRegOperands() override { return 0; }
65911         int numSrcRegOperands() override { return 0; }
65912
65913         int
65914         getOperandSize(int opIdx) override
65915         {
65916             switch (opIdx) {
65917               case 0: //vgpr_a
65918                 return 4;
65919               default:
65920                 fatal("op idx %i out of bounds\n", opIdx);
65921                 return -1;
65922             }
65923         } // getOperandSize
65924
65925         bool
65926         isSrcOperand(int opIdx) override
65927         {
65928             switch (opIdx) {
65929               case 0: //vgpr_a
65930                 return true;
65931               default:
65932                 fatal("op idx %i out of bounds\n", opIdx);
65933                 return false;
65934             }
65935         } // isSrcOperand
65936
65937         bool
65938         isDstOperand(int opIdx) override
65939         {
65940             switch (opIdx) {
65941               case 0: //vgpr_a
65942                 return false;
65943               default:
65944                 fatal("op idx %i out of bounds\n", opIdx);
65945                 return false;
65946             }
65947         } // isDstOperand
65948
65949         void execute(GPUDynInstPtr) override;
65950     }; // Inst_DS__DS_GWS_SEMA_P
65951
65952     class Inst_DS__DS_GWS_BARRIER : public Inst_DS
65953     {
65954       public:
65955         Inst_DS__DS_GWS_BARRIER(InFmt_DS*);
65956         ~Inst_DS__DS_GWS_BARRIER();
65957
65958         int
65959         getNumOperands() override
65960         {
65961             return numDstRegOperands() + numSrcRegOperands();
65962         } // getNumOperands
65963
65964         int numDstRegOperands() override { return 0; }
65965         int numSrcRegOperands() override { return 1; }
65966
65967         int
65968         getOperandSize(int opIdx) override
65969         {
65970             switch (opIdx) {
65971               case 0: //vgpr_d0
65972                 return 4;
65973               case 1: //vgpr_d0
65974                 return 4;
65975               default:
65976                 fatal("op idx %i out of bounds\n", opIdx);
65977                 return -1;
65978             }
65979         } // getOperandSize
65980
65981         bool
65982         isSrcOperand(int opIdx) override
65983         {
65984             switch (opIdx) {
65985               case 0: //vgpr_d0
65986                 return true;
65987               case 1: //vgpr_d0
65988                 return true;
65989               default:
65990                 fatal("op idx %i out of bounds\n", opIdx);
65991                 return false;
65992             }
65993         } // isSrcOperand
65994
65995         bool
65996         isDstOperand(int opIdx) override
65997         {
65998             switch (opIdx) {
65999               case 0: //vgpr_d0
66000                 return false;
66001               case 1: //vgpr_d0
66002                 return false;
66003               default:
66004                 fatal("op idx %i out of bounds\n", opIdx);
66005                 return false;
66006             }
66007         } // isDstOperand
66008
66009         void execute(GPUDynInstPtr) override;
66010     }; // Inst_DS__DS_GWS_BARRIER
66011
66012     class Inst_DS__DS_CONSUME : public Inst_DS
66013     {
66014       public:
66015         Inst_DS__DS_CONSUME(InFmt_DS*);
66016         ~Inst_DS__DS_CONSUME();
66017
66018         int
66019         getNumOperands() override
66020         {
66021             return numDstRegOperands() + numSrcRegOperands();
66022         } // getNumOperands
66023
66024         int numDstRegOperands() override { return 1; }
66025         int numSrcRegOperands() override { return 0; }
66026
66027         int
66028         getOperandSize(int opIdx) override
66029         {
66030             switch (opIdx) {
66031               case 0: //vgpr_a
66032                 return 4;
66033               case 1: //vgpr_rtn
66034                 return 4;
66035               default:
66036                 fatal("op idx %i out of bounds\n", opIdx);
66037                 return -1;
66038             }
66039         } // getOperandSize
66040
66041         bool
66042         isSrcOperand(int opIdx) override
66043         {
66044             switch (opIdx) {
66045               case 0: //vgpr_a
66046                 return true;
66047               case 1: //vgpr_rtn
66048                 return false;
66049               default:
66050                 fatal("op idx %i out of bounds\n", opIdx);
66051                 return false;
66052             }
66053         } // isSrcOperand
66054
66055         bool
66056         isDstOperand(int opIdx) override
66057         {
66058             switch (opIdx) {
66059               case 0: //vgpr_a
66060                 return false;
66061               case 1: //vgpr_rtn
66062                 return true;
66063               default:
66064                 fatal("op idx %i out of bounds\n", opIdx);
66065                 return false;
66066             }
66067         } // isDstOperand
66068
66069         void execute(GPUDynInstPtr) override;
66070     }; // Inst_DS__DS_CONSUME
66071
66072     class Inst_DS__DS_APPEND : public Inst_DS
66073     {
66074       public:
66075         Inst_DS__DS_APPEND(InFmt_DS*);
66076         ~Inst_DS__DS_APPEND();
66077
66078         int
66079         getNumOperands() override
66080         {
66081             return numDstRegOperands() + numSrcRegOperands();
66082         } // getNumOperands
66083
66084         int numDstRegOperands() override { return 1; }
66085         int numSrcRegOperands() override { return 0; }
66086
66087         int
66088         getOperandSize(int opIdx) override
66089         {
66090             switch (opIdx) {
66091               case 0: //vgpr_a
66092                 return 4;
66093               case 1: //vgpr_rtn
66094                 return 4;
66095               default:
66096                 fatal("op idx %i out of bounds\n", opIdx);
66097                 return -1;
66098             }
66099         } // getOperandSize
66100
66101         bool
66102         isSrcOperand(int opIdx) override
66103         {
66104             switch (opIdx) {
66105               case 0: //vgpr_a
66106                 return true;
66107               case 1: //vgpr_rtn
66108                 return false;
66109               default:
66110                 fatal("op idx %i out of bounds\n", opIdx);
66111                 return false;
66112             }
66113         } // isSrcOperand
66114
66115         bool
66116         isDstOperand(int opIdx) override
66117         {
66118             switch (opIdx) {
66119               case 0: //vgpr_a
66120                 return false;
66121               case 1: //vgpr_rtn
66122                 return true;
66123               default:
66124                 fatal("op idx %i out of bounds\n", opIdx);
66125                 return false;
66126             }
66127         } // isDstOperand
66128
66129         void execute(GPUDynInstPtr) override;
66130     }; // Inst_DS__DS_APPEND
66131
66132     class Inst_DS__DS_ORDERED_COUNT : public Inst_DS
66133     {
66134       public:
66135         Inst_DS__DS_ORDERED_COUNT(InFmt_DS*);
66136         ~Inst_DS__DS_ORDERED_COUNT();
66137
66138         int
66139         getNumOperands() override
66140         {
66141             return numDstRegOperands() + numSrcRegOperands();
66142         } // getNumOperands
66143
66144         int numDstRegOperands() override { return 1; }
66145         int numSrcRegOperands() override { return 1; }
66146
66147         int
66148         getOperandSize(int opIdx) override
66149         {
66150             switch (opIdx) {
66151               case 0: //vgpr_a
66152                 return 4;
66153               case 1: //vgpr_rtn
66154                 return 4;
66155               default:
66156                 fatal("op idx %i out of bounds\n", opIdx);
66157                 return -1;
66158             }
66159         } // getOperandSize
66160
66161         bool
66162         isSrcOperand(int opIdx) override
66163         {
66164             switch (opIdx) {
66165               case 0: //vgpr_a
66166                 return true;
66167               case 1: //vgpr_rtn
66168                 return false;
66169               default:
66170                 fatal("op idx %i out of bounds\n", opIdx);
66171                 return false;
66172             }
66173         } // isSrcOperand
66174
66175         bool
66176         isDstOperand(int opIdx) override
66177         {
66178             switch (opIdx) {
66179               case 0: //vgpr_a
66180                 return false;
66181               case 1: //vgpr_rtn
66182                 return true;
66183               default:
66184                 fatal("op idx %i out of bounds\n", opIdx);
66185                 return false;
66186             }
66187         } // isDstOperand
66188
66189         void execute(GPUDynInstPtr) override;
66190     }; // Inst_DS__DS_ORDERED_COUNT
66191
66192     class Inst_DS__DS_ADD_SRC2_U64 : public Inst_DS
66193     {
66194       public:
66195         Inst_DS__DS_ADD_SRC2_U64(InFmt_DS*);
66196         ~Inst_DS__DS_ADD_SRC2_U64();
66197
66198         int
66199         getNumOperands() override
66200         {
66201             return numDstRegOperands() + numSrcRegOperands();
66202         } // getNumOperands
66203
66204         int numDstRegOperands() override { return 0; }
66205         int numSrcRegOperands() override { return 1; }
66206
66207         int
66208         getOperandSize(int opIdx) override
66209         {
66210             switch (opIdx) {
66211               case 0: //vgpr_a
66212                 return 4;
66213               default:
66214                 fatal("op idx %i out of bounds\n", opIdx);
66215                 return -1;
66216             }
66217         } // getOperandSize
66218
66219         bool
66220         isSrcOperand(int opIdx) override
66221         {
66222             switch (opIdx) {
66223               case 0: //vgpr_a
66224                 return true;
66225               default:
66226                 fatal("op idx %i out of bounds\n", opIdx);
66227                 return false;
66228             }
66229         } // isSrcOperand
66230
66231         bool
66232         isDstOperand(int opIdx) override
66233         {
66234             switch (opIdx) {
66235               case 0: //vgpr_a
66236                 return false;
66237               default:
66238                 fatal("op idx %i out of bounds\n", opIdx);
66239                 return false;
66240             }
66241         } // isDstOperand
66242
66243         void execute(GPUDynInstPtr) override;
66244     }; // Inst_DS__DS_ADD_SRC2_U64
66245
66246     class Inst_DS__DS_SUB_SRC2_U64 : public Inst_DS
66247     {
66248       public:
66249         Inst_DS__DS_SUB_SRC2_U64(InFmt_DS*);
66250         ~Inst_DS__DS_SUB_SRC2_U64();
66251
66252         int
66253         getNumOperands() override
66254         {
66255             return numDstRegOperands() + numSrcRegOperands();
66256         } // getNumOperands
66257
66258         int numDstRegOperands() override { return 0; }
66259         int numSrcRegOperands() override { return 1; }
66260
66261         int
66262         getOperandSize(int opIdx) override
66263         {
66264             switch (opIdx) {
66265               case 0: //vgpr_a
66266                 return 4;
66267               default:
66268                 fatal("op idx %i out of bounds\n", opIdx);
66269                 return -1;
66270             }
66271         } // getOperandSize
66272
66273         bool
66274         isSrcOperand(int opIdx) override
66275         {
66276             switch (opIdx) {
66277               case 0: //vgpr_a
66278                 return true;
66279               default:
66280                 fatal("op idx %i out of bounds\n", opIdx);
66281                 return false;
66282             }
66283         } // isSrcOperand
66284
66285         bool
66286         isDstOperand(int opIdx) override
66287         {
66288             switch (opIdx) {
66289               case 0: //vgpr_a
66290                 return false;
66291               default:
66292                 fatal("op idx %i out of bounds\n", opIdx);
66293                 return false;
66294             }
66295         } // isDstOperand
66296
66297         void execute(GPUDynInstPtr) override;
66298     }; // Inst_DS__DS_SUB_SRC2_U64
66299
66300     class Inst_DS__DS_RSUB_SRC2_U64 : public Inst_DS
66301     {
66302       public:
66303         Inst_DS__DS_RSUB_SRC2_U64(InFmt_DS*);
66304         ~Inst_DS__DS_RSUB_SRC2_U64();
66305
66306         int
66307         getNumOperands() override
66308         {
66309             return numDstRegOperands() + numSrcRegOperands();
66310         } // getNumOperands
66311
66312         int numDstRegOperands() override { return 0; }
66313         int numSrcRegOperands() override { return 1; }
66314
66315         int
66316         getOperandSize(int opIdx) override
66317         {
66318             switch (opIdx) {
66319               case 0: //vgpr_a
66320                 return 4;
66321               default:
66322                 fatal("op idx %i out of bounds\n", opIdx);
66323                 return -1;
66324             }
66325         } // getOperandSize
66326
66327         bool
66328         isSrcOperand(int opIdx) override
66329         {
66330             switch (opIdx) {
66331               case 0: //vgpr_a
66332                 return true;
66333               default:
66334                 fatal("op idx %i out of bounds\n", opIdx);
66335                 return false;
66336             }
66337         } // isSrcOperand
66338
66339         bool
66340         isDstOperand(int opIdx) override
66341         {
66342             switch (opIdx) {
66343               case 0: //vgpr_a
66344                 return false;
66345               default:
66346                 fatal("op idx %i out of bounds\n", opIdx);
66347                 return false;
66348             }
66349         } // isDstOperand
66350
66351         void execute(GPUDynInstPtr) override;
66352     }; // Inst_DS__DS_RSUB_SRC2_U64
66353
66354     class Inst_DS__DS_INC_SRC2_U64 : public Inst_DS
66355     {
66356       public:
66357         Inst_DS__DS_INC_SRC2_U64(InFmt_DS*);
66358         ~Inst_DS__DS_INC_SRC2_U64();
66359
66360         int
66361         getNumOperands() override
66362         {
66363             return numDstRegOperands() + numSrcRegOperands();
66364         } // getNumOperands
66365
66366         int numDstRegOperands() override { return 0; }
66367         int numSrcRegOperands() override { return 1; }
66368
66369         int
66370         getOperandSize(int opIdx) override
66371         {
66372             switch (opIdx) {
66373               case 0: //vgpr_a
66374                 return 4;
66375               default:
66376                 fatal("op idx %i out of bounds\n", opIdx);
66377                 return -1;
66378             }
66379         } // getOperandSize
66380
66381         bool
66382         isSrcOperand(int opIdx) override
66383         {
66384             switch (opIdx) {
66385               case 0: //vgpr_a
66386                 return true;
66387               default:
66388                 fatal("op idx %i out of bounds\n", opIdx);
66389                 return false;
66390             }
66391         } // isSrcOperand
66392
66393         bool
66394         isDstOperand(int opIdx) override
66395         {
66396             switch (opIdx) {
66397               case 0: //vgpr_a
66398                 return false;
66399               default:
66400                 fatal("op idx %i out of bounds\n", opIdx);
66401                 return false;
66402             }
66403         } // isDstOperand
66404
66405         void execute(GPUDynInstPtr) override;
66406     }; // Inst_DS__DS_INC_SRC2_U64
66407
66408     class Inst_DS__DS_DEC_SRC2_U64 : public Inst_DS
66409     {
66410       public:
66411         Inst_DS__DS_DEC_SRC2_U64(InFmt_DS*);
66412         ~Inst_DS__DS_DEC_SRC2_U64();
66413
66414         int
66415         getNumOperands() override
66416         {
66417             return numDstRegOperands() + numSrcRegOperands();
66418         } // getNumOperands
66419
66420         int numDstRegOperands() override { return 0; }
66421         int numSrcRegOperands() override { return 1; }
66422
66423         int
66424         getOperandSize(int opIdx) override
66425         {
66426             switch (opIdx) {
66427               case 0: //vgpr_a
66428                 return 4;
66429               default:
66430                 fatal("op idx %i out of bounds\n", opIdx);
66431                 return -1;
66432             }
66433         } // getOperandSize
66434
66435         bool
66436         isSrcOperand(int opIdx) override
66437         {
66438             switch (opIdx) {
66439               case 0: //vgpr_a
66440                 return true;
66441               default:
66442                 fatal("op idx %i out of bounds\n", opIdx);
66443                 return false;
66444             }
66445         } // isSrcOperand
66446
66447         bool
66448         isDstOperand(int opIdx) override
66449         {
66450             switch (opIdx) {
66451               case 0: //vgpr_a
66452                 return false;
66453               default:
66454                 fatal("op idx %i out of bounds\n", opIdx);
66455                 return false;
66456             }
66457         } // isDstOperand
66458
66459         void execute(GPUDynInstPtr) override;
66460     }; // Inst_DS__DS_DEC_SRC2_U64
66461
66462     class Inst_DS__DS_MIN_SRC2_I64 : public Inst_DS
66463     {
66464       public:
66465         Inst_DS__DS_MIN_SRC2_I64(InFmt_DS*);
66466         ~Inst_DS__DS_MIN_SRC2_I64();
66467
66468         int
66469         getNumOperands() override
66470         {
66471             return numDstRegOperands() + numSrcRegOperands();
66472         } // getNumOperands
66473
66474         int numDstRegOperands() override { return 0; }
66475         int numSrcRegOperands() override { return 1; }
66476
66477         int
66478         getOperandSize(int opIdx) override
66479         {
66480             switch (opIdx) {
66481               case 0: //vgpr_a
66482                 return 4;
66483               default:
66484                 fatal("op idx %i out of bounds\n", opIdx);
66485                 return -1;
66486             }
66487         } // getOperandSize
66488
66489         bool
66490         isSrcOperand(int opIdx) override
66491         {
66492             switch (opIdx) {
66493               case 0: //vgpr_a
66494                 return true;
66495               default:
66496                 fatal("op idx %i out of bounds\n", opIdx);
66497                 return false;
66498             }
66499         } // isSrcOperand
66500
66501         bool
66502         isDstOperand(int opIdx) override
66503         {
66504             switch (opIdx) {
66505               case 0: //vgpr_a
66506                 return false;
66507               default:
66508                 fatal("op idx %i out of bounds\n", opIdx);
66509                 return false;
66510             }
66511         } // isDstOperand
66512
66513         void execute(GPUDynInstPtr) override;
66514     }; // Inst_DS__DS_MIN_SRC2_I64
66515
66516     class Inst_DS__DS_MAX_SRC2_I64 : public Inst_DS
66517     {
66518       public:
66519         Inst_DS__DS_MAX_SRC2_I64(InFmt_DS*);
66520         ~Inst_DS__DS_MAX_SRC2_I64();
66521
66522         int
66523         getNumOperands() override
66524         {
66525             return numDstRegOperands() + numSrcRegOperands();
66526         } // getNumOperands
66527
66528         int numDstRegOperands() override { return 0; }
66529         int numSrcRegOperands() override { return 1; }
66530
66531         int
66532         getOperandSize(int opIdx) override
66533         {
66534             switch (opIdx) {
66535               case 0: //vgpr_a
66536                 return 4;
66537               default:
66538                 fatal("op idx %i out of bounds\n", opIdx);
66539                 return -1;
66540             }
66541         } // getOperandSize
66542
66543         bool
66544         isSrcOperand(int opIdx) override
66545         {
66546             switch (opIdx) {
66547               case 0: //vgpr_a
66548                 return true;
66549               default:
66550                 fatal("op idx %i out of bounds\n", opIdx);
66551                 return false;
66552             }
66553         } // isSrcOperand
66554
66555         bool
66556         isDstOperand(int opIdx) override
66557         {
66558             switch (opIdx) {
66559               case 0: //vgpr_a
66560                 return false;
66561               default:
66562                 fatal("op idx %i out of bounds\n", opIdx);
66563                 return false;
66564             }
66565         } // isDstOperand
66566
66567         void execute(GPUDynInstPtr) override;
66568     }; // Inst_DS__DS_MAX_SRC2_I64
66569
66570     class Inst_DS__DS_MIN_SRC2_U64 : public Inst_DS
66571     {
66572       public:
66573         Inst_DS__DS_MIN_SRC2_U64(InFmt_DS*);
66574         ~Inst_DS__DS_MIN_SRC2_U64();
66575
66576         int
66577         getNumOperands() override
66578         {
66579             return numDstRegOperands() + numSrcRegOperands();
66580         } // getNumOperands
66581
66582         int numDstRegOperands() override { return 0; }
66583         int numSrcRegOperands() override { return 1; }
66584
66585         int
66586         getOperandSize(int opIdx) override
66587         {
66588             switch (opIdx) {
66589               case 0: //vgpr_a
66590                 return 4;
66591               default:
66592                 fatal("op idx %i out of bounds\n", opIdx);
66593                 return -1;
66594             }
66595         } // getOperandSize
66596
66597         bool
66598         isSrcOperand(int opIdx) override
66599         {
66600             switch (opIdx) {
66601               case 0: //vgpr_a
66602                 return true;
66603               default:
66604                 fatal("op idx %i out of bounds\n", opIdx);
66605                 return false;
66606             }
66607         } // isSrcOperand
66608
66609         bool
66610         isDstOperand(int opIdx) override
66611         {
66612             switch (opIdx) {
66613               case 0: //vgpr_a
66614                 return false;
66615               default:
66616                 fatal("op idx %i out of bounds\n", opIdx);
66617                 return false;
66618             }
66619         } // isDstOperand
66620
66621         void execute(GPUDynInstPtr) override;
66622     }; // Inst_DS__DS_MIN_SRC2_U64
66623
66624     class Inst_DS__DS_MAX_SRC2_U64 : public Inst_DS
66625     {
66626       public:
66627         Inst_DS__DS_MAX_SRC2_U64(InFmt_DS*);
66628         ~Inst_DS__DS_MAX_SRC2_U64();
66629
66630         int
66631         getNumOperands() override
66632         {
66633             return numDstRegOperands() + numSrcRegOperands();
66634         } // getNumOperands
66635
66636         int numDstRegOperands() override { return 0; }
66637         int numSrcRegOperands() override { return 1; }
66638
66639         int
66640         getOperandSize(int opIdx) override
66641         {
66642             switch (opIdx) {
66643               case 0: //vgpr_a
66644                 return 4;
66645               default:
66646                 fatal("op idx %i out of bounds\n", opIdx);
66647                 return -1;
66648             }
66649         } // getOperandSize
66650
66651         bool
66652         isSrcOperand(int opIdx) override
66653         {
66654             switch (opIdx) {
66655               case 0: //vgpr_a
66656                 return true;
66657               default:
66658                 fatal("op idx %i out of bounds\n", opIdx);
66659                 return false;
66660             }
66661         } // isSrcOperand
66662
66663         bool
66664         isDstOperand(int opIdx) override
66665         {
66666             switch (opIdx) {
66667               case 0: //vgpr_a
66668                 return false;
66669               default:
66670                 fatal("op idx %i out of bounds\n", opIdx);
66671                 return false;
66672             }
66673         } // isDstOperand
66674
66675         void execute(GPUDynInstPtr) override;
66676     }; // Inst_DS__DS_MAX_SRC2_U64
66677
66678     class Inst_DS__DS_AND_SRC2_B64 : public Inst_DS
66679     {
66680       public:
66681         Inst_DS__DS_AND_SRC2_B64(InFmt_DS*);
66682         ~Inst_DS__DS_AND_SRC2_B64();
66683
66684         int
66685         getNumOperands() override
66686         {
66687             return numDstRegOperands() + numSrcRegOperands();
66688         } // getNumOperands
66689
66690         int numDstRegOperands() override { return 0; }
66691         int numSrcRegOperands() override { return 1; }
66692
66693         int
66694         getOperandSize(int opIdx) override
66695         {
66696             switch (opIdx) {
66697               case 0: //vgpr_a
66698                 return 4;
66699               default:
66700                 fatal("op idx %i out of bounds\n", opIdx);
66701                 return -1;
66702             }
66703         } // getOperandSize
66704
66705         bool
66706         isSrcOperand(int opIdx) override
66707         {
66708             switch (opIdx) {
66709               case 0: //vgpr_a
66710                 return true;
66711               default:
66712                 fatal("op idx %i out of bounds\n", opIdx);
66713                 return false;
66714             }
66715         } // isSrcOperand
66716
66717         bool
66718         isDstOperand(int opIdx) override
66719         {
66720             switch (opIdx) {
66721               case 0: //vgpr_a
66722                 return false;
66723               default:
66724                 fatal("op idx %i out of bounds\n", opIdx);
66725                 return false;
66726             }
66727         } // isDstOperand
66728
66729         void execute(GPUDynInstPtr) override;
66730     }; // Inst_DS__DS_AND_SRC2_B64
66731
66732     class Inst_DS__DS_OR_SRC2_B64 : public Inst_DS
66733     {
66734       public:
66735         Inst_DS__DS_OR_SRC2_B64(InFmt_DS*);
66736         ~Inst_DS__DS_OR_SRC2_B64();
66737
66738         int
66739         getNumOperands() override
66740         {
66741             return numDstRegOperands() + numSrcRegOperands();
66742         } // getNumOperands
66743
66744         int numDstRegOperands() override { return 0; }
66745         int numSrcRegOperands() override { return 1; }
66746
66747         int
66748         getOperandSize(int opIdx) override
66749         {
66750             switch (opIdx) {
66751               case 0: //vgpr_a
66752                 return 4;
66753               default:
66754                 fatal("op idx %i out of bounds\n", opIdx);
66755                 return -1;
66756             }
66757         } // getOperandSize
66758
66759         bool
66760         isSrcOperand(int opIdx) override
66761         {
66762             switch (opIdx) {
66763               case 0: //vgpr_a
66764                 return true;
66765               default:
66766                 fatal("op idx %i out of bounds\n", opIdx);
66767                 return false;
66768             }
66769         } // isSrcOperand
66770
66771         bool
66772         isDstOperand(int opIdx) override
66773         {
66774             switch (opIdx) {
66775               case 0: //vgpr_a
66776                 return false;
66777               default:
66778                 fatal("op idx %i out of bounds\n", opIdx);
66779                 return false;
66780             }
66781         } // isDstOperand
66782
66783         void execute(GPUDynInstPtr) override;
66784     }; // Inst_DS__DS_OR_SRC2_B64
66785
66786     class Inst_DS__DS_XOR_SRC2_B64 : public Inst_DS
66787     {
66788       public:
66789         Inst_DS__DS_XOR_SRC2_B64(InFmt_DS*);
66790         ~Inst_DS__DS_XOR_SRC2_B64();
66791
66792         int
66793         getNumOperands() override
66794         {
66795             return numDstRegOperands() + numSrcRegOperands();
66796         } // getNumOperands
66797
66798         int numDstRegOperands() override { return 0; }
66799         int numSrcRegOperands() override { return 1; }
66800
66801         int
66802         getOperandSize(int opIdx) override
66803         {
66804             switch (opIdx) {
66805               case 0: //vgpr_a
66806                 return 4;
66807               default:
66808                 fatal("op idx %i out of bounds\n", opIdx);
66809                 return -1;
66810             }
66811         } // getOperandSize
66812
66813         bool
66814         isSrcOperand(int opIdx) override
66815         {
66816             switch (opIdx) {
66817               case 0: //vgpr_a
66818                 return true;
66819               default:
66820                 fatal("op idx %i out of bounds\n", opIdx);
66821                 return false;
66822             }
66823         } // isSrcOperand
66824
66825         bool
66826         isDstOperand(int opIdx) override
66827         {
66828             switch (opIdx) {
66829               case 0: //vgpr_a
66830                 return false;
66831               default:
66832                 fatal("op idx %i out of bounds\n", opIdx);
66833                 return false;
66834             }
66835         } // isDstOperand
66836
66837         void execute(GPUDynInstPtr) override;
66838     }; // Inst_DS__DS_XOR_SRC2_B64
66839
66840     class Inst_DS__DS_WRITE_SRC2_B64 : public Inst_DS
66841     {
66842       public:
66843         Inst_DS__DS_WRITE_SRC2_B64(InFmt_DS*);
66844         ~Inst_DS__DS_WRITE_SRC2_B64();
66845
66846         int
66847         getNumOperands() override
66848         {
66849             return numDstRegOperands() + numSrcRegOperands();
66850         } // getNumOperands
66851
66852         int numDstRegOperands() override { return 0; }
66853         int numSrcRegOperands() override { return 1; }
66854
66855         int
66856         getOperandSize(int opIdx) override
66857         {
66858             switch (opIdx) {
66859               case 0: //vgpr_a
66860                 return 4;
66861               default:
66862                 fatal("op idx %i out of bounds\n", opIdx);
66863                 return -1;
66864             }
66865         } // getOperandSize
66866
66867         bool
66868         isSrcOperand(int opIdx) override
66869         {
66870             switch (opIdx) {
66871               case 0: //vgpr_a
66872                 return true;
66873               default:
66874                 fatal("op idx %i out of bounds\n", opIdx);
66875                 return false;
66876             }
66877         } // isSrcOperand
66878
66879         bool
66880         isDstOperand(int opIdx) override
66881         {
66882             switch (opIdx) {
66883               case 0: //vgpr_a
66884                 return false;
66885               default:
66886                 fatal("op idx %i out of bounds\n", opIdx);
66887                 return false;
66888             }
66889         } // isDstOperand
66890
66891         void execute(GPUDynInstPtr) override;
66892     }; // Inst_DS__DS_WRITE_SRC2_B64
66893
66894     class Inst_DS__DS_MIN_SRC2_F64 : public Inst_DS
66895     {
66896       public:
66897         Inst_DS__DS_MIN_SRC2_F64(InFmt_DS*);
66898         ~Inst_DS__DS_MIN_SRC2_F64();
66899
66900         int
66901         getNumOperands() override
66902         {
66903             return numDstRegOperands() + numSrcRegOperands();
66904         } // getNumOperands
66905
66906         int numDstRegOperands() override { return 0; }
66907         int numSrcRegOperands() override { return 1; }
66908
66909         int
66910         getOperandSize(int opIdx) override
66911         {
66912             switch (opIdx) {
66913               case 0: //vgpr_a
66914                 return 4;
66915               default:
66916                 fatal("op idx %i out of bounds\n", opIdx);
66917                 return -1;
66918             }
66919         } // getOperandSize
66920
66921         bool
66922         isSrcOperand(int opIdx) override
66923         {
66924             switch (opIdx) {
66925               case 0: //vgpr_a
66926                 return true;
66927               default:
66928                 fatal("op idx %i out of bounds\n", opIdx);
66929                 return false;
66930             }
66931         } // isSrcOperand
66932
66933         bool
66934         isDstOperand(int opIdx) override
66935         {
66936             switch (opIdx) {
66937               case 0: //vgpr_a
66938                 return false;
66939               default:
66940                 fatal("op idx %i out of bounds\n", opIdx);
66941                 return false;
66942             }
66943         } // isDstOperand
66944
66945         void execute(GPUDynInstPtr) override;
66946     }; // Inst_DS__DS_MIN_SRC2_F64
66947
66948     class Inst_DS__DS_MAX_SRC2_F64 : public Inst_DS
66949     {
66950       public:
66951         Inst_DS__DS_MAX_SRC2_F64(InFmt_DS*);
66952         ~Inst_DS__DS_MAX_SRC2_F64();
66953
66954         int
66955         getNumOperands() override
66956         {
66957             return numDstRegOperands() + numSrcRegOperands();
66958         } // getNumOperands
66959
66960         int numDstRegOperands() override { return 0; }
66961         int numSrcRegOperands() override { return 1; }
66962
66963         int
66964         getOperandSize(int opIdx) override
66965         {
66966             switch (opIdx) {
66967               case 0: //vgpr_a
66968                 return 4;
66969               default:
66970                 fatal("op idx %i out of bounds\n", opIdx);
66971                 return -1;
66972             }
66973         } // getOperandSize
66974
66975         bool
66976         isSrcOperand(int opIdx) override
66977         {
66978             switch (opIdx) {
66979               case 0: //vgpr_a
66980                 return true;
66981               default:
66982                 fatal("op idx %i out of bounds\n", opIdx);
66983                 return false;
66984             }
66985         } // isSrcOperand
66986
66987         bool
66988         isDstOperand(int opIdx) override
66989         {
66990             switch (opIdx) {
66991               case 0: //vgpr_a
66992                 return false;
66993               default:
66994                 fatal("op idx %i out of bounds\n", opIdx);
66995                 return false;
66996             }
66997         } // isDstOperand
66998
66999         void execute(GPUDynInstPtr) override;
67000     }; // Inst_DS__DS_MAX_SRC2_F64
67001
67002     class Inst_DS__DS_WRITE_B96 : public Inst_DS
67003     {
67004       public:
67005         Inst_DS__DS_WRITE_B96(InFmt_DS*);
67006         ~Inst_DS__DS_WRITE_B96();
67007
67008         int
67009         getNumOperands() override
67010         {
67011             return numDstRegOperands() + numSrcRegOperands();
67012         } // getNumOperands
67013
67014         int numDstRegOperands() override { return 0; }
67015         int numSrcRegOperands() override { return 2; }
67016
67017         int
67018         getOperandSize(int opIdx) override
67019         {
67020             switch (opIdx) {
67021               case 0: //vgpr_a
67022                 return 4;
67023               case 1: //vgpr_d0
67024                 return 12;
67025               default:
67026                 fatal("op idx %i out of bounds\n", opIdx);
67027                 return -1;
67028             }
67029         } // getOperandSize
67030
67031         bool
67032         isSrcOperand(int opIdx) override
67033         {
67034             switch (opIdx) {
67035               case 0: //vgpr_a
67036                 return true;
67037               case 1: //vgpr_d0
67038                 return true;
67039               default:
67040                 fatal("op idx %i out of bounds\n", opIdx);
67041                 return false;
67042             }
67043         } // isSrcOperand
67044
67045         bool
67046         isDstOperand(int opIdx) override
67047         {
67048             switch (opIdx) {
67049               case 0: //vgpr_a
67050                 return false;
67051               case 1: //vgpr_d0
67052                 return false;
67053               default:
67054                 fatal("op idx %i out of bounds\n", opIdx);
67055                 return false;
67056             }
67057         } // isDstOperand
67058
67059         void execute(GPUDynInstPtr) override;
67060     }; // Inst_DS__DS_WRITE_B96
67061
67062     class Inst_DS__DS_WRITE_B128 : public Inst_DS
67063     {
67064       public:
67065         Inst_DS__DS_WRITE_B128(InFmt_DS*);
67066         ~Inst_DS__DS_WRITE_B128();
67067
67068         int
67069         getNumOperands() override
67070         {
67071             return numDstRegOperands() + numSrcRegOperands();
67072         } // getNumOperands
67073
67074         int numDstRegOperands() override { return 0; }
67075         int numSrcRegOperands() override { return 2; }
67076
67077         int
67078         getOperandSize(int opIdx) override
67079         {
67080             switch (opIdx) {
67081               case 0: //vgpr_a
67082                 return 4;
67083               case 1: //vgpr_d0
67084                 return 16;
67085               default:
67086                 fatal("op idx %i out of bounds\n", opIdx);
67087                 return -1;
67088             }
67089         } // getOperandSize
67090
67091         bool
67092         isSrcOperand(int opIdx) override
67093         {
67094             switch (opIdx) {
67095               case 0: //vgpr_a
67096                 return true;
67097               case 1: //vgpr_d0
67098                 return true;
67099               default:
67100                 fatal("op idx %i out of bounds\n", opIdx);
67101                 return false;
67102             }
67103         } // isSrcOperand
67104
67105         bool
67106         isDstOperand(int opIdx) override
67107         {
67108             switch (opIdx) {
67109               case 0: //vgpr_a
67110                 return false;
67111               case 1: //vgpr_d0
67112                 return false;
67113               default:
67114                 fatal("op idx %i out of bounds\n", opIdx);
67115                 return false;
67116             }
67117         } // isDstOperand
67118
67119         void execute(GPUDynInstPtr) override;
67120     }; // Inst_DS__DS_WRITE_B128
67121
67122     class Inst_DS__DS_READ_B96 : public Inst_DS
67123     {
67124       public:
67125         Inst_DS__DS_READ_B96(InFmt_DS*);
67126         ~Inst_DS__DS_READ_B96();
67127
67128         int
67129         getNumOperands() override
67130         {
67131             return numDstRegOperands() + numSrcRegOperands();
67132         } // getNumOperands
67133
67134         int numDstRegOperands() override { return 1; }
67135         int numSrcRegOperands() override { return 1; }
67136
67137         int
67138         getOperandSize(int opIdx) override
67139         {
67140             switch (opIdx) {
67141               case 0: //vgpr_a
67142                 return 4;
67143               case 1: //vgpr_rtn
67144                 return 12;
67145               default:
67146                 fatal("op idx %i out of bounds\n", opIdx);
67147                 return -1;
67148             }
67149         } // getOperandSize
67150
67151         bool
67152         isSrcOperand(int opIdx) override
67153         {
67154             switch (opIdx) {
67155               case 0: //vgpr_a
67156                 return true;
67157               case 1: //vgpr_rtn
67158                 return false;
67159               default:
67160                 fatal("op idx %i out of bounds\n", opIdx);
67161                 return false;
67162             }
67163         } // isSrcOperand
67164
67165         bool
67166         isDstOperand(int opIdx) override
67167         {
67168             switch (opIdx) {
67169               case 0: //vgpr_a
67170                 return false;
67171               case 1: //vgpr_rtn
67172                 return true;
67173               default:
67174                 fatal("op idx %i out of bounds\n", opIdx);
67175                 return false;
67176             }
67177         } // isDstOperand
67178
67179         void execute(GPUDynInstPtr) override;
67180     }; // Inst_DS__DS_READ_B96
67181
67182     class Inst_DS__DS_READ_B128 : public Inst_DS
67183     {
67184       public:
67185         Inst_DS__DS_READ_B128(InFmt_DS*);
67186         ~Inst_DS__DS_READ_B128();
67187
67188         int
67189         getNumOperands() override
67190         {
67191             return numDstRegOperands() + numSrcRegOperands();
67192         } // getNumOperands
67193
67194         int numDstRegOperands() override { return 1; }
67195         int numSrcRegOperands() override { return 1; }
67196
67197         int
67198         getOperandSize(int opIdx) override
67199         {
67200             switch (opIdx) {
67201               case 0: //vgpr_a
67202                 return 4;
67203               case 1: //vgpr_rtn
67204                 return 16;
67205               default:
67206                 fatal("op idx %i out of bounds\n", opIdx);
67207                 return -1;
67208             }
67209         } // getOperandSize
67210
67211         bool
67212         isSrcOperand(int opIdx) override
67213         {
67214             switch (opIdx) {
67215               case 0: //vgpr_a
67216                 return true;
67217               case 1: //vgpr_rtn
67218                 return false;
67219               default:
67220                 fatal("op idx %i out of bounds\n", opIdx);
67221                 return false;
67222             }
67223         } // isSrcOperand
67224
67225         bool
67226         isDstOperand(int opIdx) override
67227         {
67228             switch (opIdx) {
67229               case 0: //vgpr_a
67230                 return false;
67231               case 1: //vgpr_rtn
67232                 return true;
67233               default:
67234                 fatal("op idx %i out of bounds\n", opIdx);
67235                 return false;
67236             }
67237         } // isDstOperand
67238
67239         void execute(GPUDynInstPtr) override;
67240     }; // Inst_DS__DS_READ_B128
67241
67242     class Inst_MUBUF__BUFFER_LOAD_FORMAT_X : public Inst_MUBUF
67243     {
67244       public:
67245         Inst_MUBUF__BUFFER_LOAD_FORMAT_X(InFmt_MUBUF*);
67246         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_X();
67247
67248         int
67249         getNumOperands() override
67250         {
67251             return numDstRegOperands() + numSrcRegOperands();
67252         } // getNumOperands
67253
67254         int numDstRegOperands() override { return 1; }
67255         int numSrcRegOperands() override { return 3; }
67256
67257         int
67258         getOperandSize(int opIdx) override
67259         {
67260             switch (opIdx) {
67261               case 0: //vgpr_a
67262                 return 8;
67263               case 1: //sgpr_r
67264                 return 4;
67265               case 2: //sgpr_o
67266                 return 4;
67267               case 3: //vgpr_d
67268                 return 32;
67269               default:
67270                 fatal("op idx %i out of bounds\n", opIdx);
67271                 return -1;
67272             }
67273         } // getOperandSize
67274
67275         bool
67276         isSrcOperand(int opIdx) override
67277         {
67278             switch (opIdx) {
67279               case 0: //vgpr_a
67280                 return true;
67281               case 1: //sgpr_r
67282                 return true;
67283               case 2: //sgpr_o
67284                 return true;
67285               case 3: //vgpr_d
67286                 return false;
67287               default:
67288                 fatal("op idx %i out of bounds\n", opIdx);
67289                 return false;
67290             }
67291         } // isSrcOperand
67292
67293         bool
67294         isDstOperand(int opIdx) override
67295         {
67296             switch (opIdx) {
67297               case 0: //vgpr_a
67298                 return false;
67299               case 1: //sgpr_r
67300                 return false;
67301               case 2: //sgpr_o
67302                 return false;
67303               case 3: //vgpr_d
67304                 return true;
67305               default:
67306                 fatal("op idx %i out of bounds\n", opIdx);
67307                 return false;
67308             }
67309         } // isDstOperand
67310
67311         void execute(GPUDynInstPtr) override;
67312         void initiateAcc(GPUDynInstPtr) override;
67313         void completeAcc(GPUDynInstPtr) override;
67314     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_X
67315
67316     class Inst_MUBUF__BUFFER_LOAD_FORMAT_XY : public Inst_MUBUF
67317     {
67318       public:
67319         Inst_MUBUF__BUFFER_LOAD_FORMAT_XY(InFmt_MUBUF*);
67320         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_XY();
67321
67322         int
67323         getNumOperands() override
67324         {
67325             return numDstRegOperands() + numSrcRegOperands();
67326         } // getNumOperands
67327
67328         int numDstRegOperands() override { return 1; }
67329         int numSrcRegOperands() override { return 3; }
67330
67331         int
67332         getOperandSize(int opIdx) override
67333         {
67334             switch (opIdx) {
67335               case 0: //vgpr_a
67336                 return 8;
67337               case 1: //sgpr_r
67338                 return 4;
67339               case 2: //sgpr_o
67340                 return 4;
67341               case 3: //vgpr_d
67342                 return 8;
67343               default:
67344                 fatal("op idx %i out of bounds\n", opIdx);
67345                 return -1;
67346             }
67347         } // getOperandSize
67348
67349         bool
67350         isSrcOperand(int opIdx) override
67351         {
67352             switch (opIdx) {
67353               case 0: //vgpr_a
67354                 return true;
67355               case 1: //sgpr_r
67356                 return true;
67357               case 2: //sgpr_o
67358                 return true;
67359               case 3: //vgpr_d
67360                 return false;
67361               default:
67362                 fatal("op idx %i out of bounds\n", opIdx);
67363                 return false;
67364             }
67365         } // isSrcOperand
67366
67367         bool
67368         isDstOperand(int opIdx) override
67369         {
67370             switch (opIdx) {
67371               case 0: //vgpr_a
67372                 return false;
67373               case 1: //sgpr_r
67374                 return false;
67375               case 2: //sgpr_o
67376                 return false;
67377               case 3: //vgpr_d
67378                 return true;
67379               default:
67380                 fatal("op idx %i out of bounds\n", opIdx);
67381                 return false;
67382             }
67383         } // isDstOperand
67384
67385         void execute(GPUDynInstPtr) override;
67386         void initiateAcc(GPUDynInstPtr) override;
67387         void completeAcc(GPUDynInstPtr) override;
67388     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_XY
67389
67390     class Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZ : public Inst_MUBUF
67391     {
67392       public:
67393         Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZ(InFmt_MUBUF*);
67394         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZ();
67395
67396         int
67397         getNumOperands() override
67398         {
67399             return numDstRegOperands() + numSrcRegOperands();
67400         } // getNumOperands
67401
67402         int numDstRegOperands() override { return 1; }
67403         int numSrcRegOperands() override { return 3; }
67404
67405         int
67406         getOperandSize(int opIdx) override
67407         {
67408             switch (opIdx) {
67409               case 0: //vgpr_a
67410                 return 8;
67411               case 1: //sgpr_r
67412                 return 4;
67413               case 2: //sgpr_o
67414                 return 4;
67415               case 3: //vgpr_d
67416                 return 12;
67417               default:
67418                 fatal("op idx %i out of bounds\n", opIdx);
67419                 return -1;
67420             }
67421         } // getOperandSize
67422
67423         bool
67424         isSrcOperand(int opIdx) override
67425         {
67426             switch (opIdx) {
67427               case 0: //vgpr_a
67428                 return true;
67429               case 1: //sgpr_r
67430                 return true;
67431               case 2: //sgpr_o
67432                 return true;
67433               case 3: //vgpr_d
67434                 return false;
67435               default:
67436                 fatal("op idx %i out of bounds\n", opIdx);
67437                 return false;
67438             }
67439         } // isSrcOperand
67440
67441         bool
67442         isDstOperand(int opIdx) override
67443         {
67444             switch (opIdx) {
67445               case 0: //vgpr_a
67446                 return false;
67447               case 1: //sgpr_r
67448                 return false;
67449               case 2: //sgpr_o
67450                 return false;
67451               case 3: //vgpr_d
67452                 return true;
67453               default:
67454                 fatal("op idx %i out of bounds\n", opIdx);
67455                 return false;
67456             }
67457         } // isDstOperand
67458
67459         void execute(GPUDynInstPtr) override;
67460         void initiateAcc(GPUDynInstPtr) override;
67461         void completeAcc(GPUDynInstPtr) override;
67462     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZ
67463
67464     class Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZW : public Inst_MUBUF
67465     {
67466       public:
67467         Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZW(InFmt_MUBUF*);
67468         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZW();
67469
67470         int
67471         getNumOperands() override
67472         {
67473             return numDstRegOperands() + numSrcRegOperands();
67474         } // getNumOperands
67475
67476         int numDstRegOperands() override { return 1; }
67477         int numSrcRegOperands() override { return 3; }
67478
67479         int
67480         getOperandSize(int opIdx) override
67481         {
67482             switch (opIdx) {
67483               case 0: //vgpr_a
67484                 return 8;
67485               case 1: //sgpr_r
67486                 return 4;
67487               case 2: //sgpr_o
67488                 return 4;
67489               case 3: //vgpr_d
67490                 return 16;
67491               default:
67492                 fatal("op idx %i out of bounds\n", opIdx);
67493                 return -1;
67494             }
67495         } // getOperandSize
67496
67497         bool
67498         isSrcOperand(int opIdx) override
67499         {
67500             switch (opIdx) {
67501               case 0: //vgpr_a
67502                 return true;
67503               case 1: //sgpr_r
67504                 return true;
67505               case 2: //sgpr_o
67506                 return true;
67507               case 3: //vgpr_d
67508                 return false;
67509               default:
67510                 fatal("op idx %i out of bounds\n", opIdx);
67511                 return false;
67512             }
67513         } // isSrcOperand
67514
67515         bool
67516         isDstOperand(int opIdx) override
67517         {
67518             switch (opIdx) {
67519               case 0: //vgpr_a
67520                 return false;
67521               case 1: //sgpr_r
67522                 return false;
67523               case 2: //sgpr_o
67524                 return false;
67525               case 3: //vgpr_d
67526                 return true;
67527               default:
67528                 fatal("op idx %i out of bounds\n", opIdx);
67529                 return false;
67530             }
67531         } // isDstOperand
67532
67533         void execute(GPUDynInstPtr) override;
67534         void initiateAcc(GPUDynInstPtr) override;
67535         void completeAcc(GPUDynInstPtr) override;
67536     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_XYZW
67537
67538     class Inst_MUBUF__BUFFER_STORE_FORMAT_X : public Inst_MUBUF
67539     {
67540       public:
67541         Inst_MUBUF__BUFFER_STORE_FORMAT_X(InFmt_MUBUF*);
67542         ~Inst_MUBUF__BUFFER_STORE_FORMAT_X();
67543
67544         int
67545         getNumOperands() override
67546         {
67547             return numDstRegOperands() + numSrcRegOperands();
67548         } // getNumOperands
67549
67550         int numDstRegOperands() override { return 0; }
67551         int numSrcRegOperands() override { return 4; }
67552
67553         int
67554         getOperandSize(int opIdx) override
67555         {
67556             switch (opIdx) {
67557               case 0: //vgpr_s
67558                 return 4;
67559               case 1: //vgpr_a
67560                 return 8;
67561               case 2: //sgpr_r
67562                 return 4;
67563               case 3: //sgpr_o
67564                 return 4;
67565               default:
67566                 fatal("op idx %i out of bounds\n", opIdx);
67567                 return -1;
67568             }
67569         } // getOperandSize
67570
67571         bool
67572         isSrcOperand(int opIdx) override
67573         {
67574             switch (opIdx) {
67575               case 0: //vgpr_s
67576                 return true;
67577               case 1: //vgpr_a
67578                 return true;
67579               case 2: //sgpr_r
67580                 return true;
67581               case 3: //sgpr_o
67582                 return true;
67583               default:
67584                 fatal("op idx %i out of bounds\n", opIdx);
67585                 return false;
67586             }
67587         } // isSrcOperand
67588
67589         bool
67590         isDstOperand(int opIdx) override
67591         {
67592             switch (opIdx) {
67593               case 0: //vgpr_s
67594                 return false;
67595               case 1: //vgpr_a
67596                 return false;
67597               case 2: //sgpr_r
67598                 return false;
67599               case 3: //sgpr_o
67600                 return false;
67601               default:
67602                 fatal("op idx %i out of bounds\n", opIdx);
67603                 return false;
67604             }
67605         } // isDstOperand
67606
67607         void execute(GPUDynInstPtr) override;
67608         void initiateAcc(GPUDynInstPtr) override;
67609         void completeAcc(GPUDynInstPtr) override;
67610     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_X
67611
67612     class Inst_MUBUF__BUFFER_STORE_FORMAT_XY : public Inst_MUBUF
67613     {
67614       public:
67615         Inst_MUBUF__BUFFER_STORE_FORMAT_XY(InFmt_MUBUF*);
67616         ~Inst_MUBUF__BUFFER_STORE_FORMAT_XY();
67617
67618         int
67619         getNumOperands() override
67620         {
67621             return numDstRegOperands() + numSrcRegOperands();
67622         } // getNumOperands
67623
67624         int numDstRegOperands() override { return 0; }
67625         int numSrcRegOperands() override { return 4; }
67626
67627         int
67628         getOperandSize(int opIdx) override
67629         {
67630             switch (opIdx) {
67631               case 0: //vgpr_s
67632                 return 8;
67633               case 1: //vgpr_a
67634                 return 8;
67635               case 2: //sgpr_r
67636                 return 4;
67637               case 3: //sgpr_o
67638                 return 4;
67639               default:
67640                 fatal("op idx %i out of bounds\n", opIdx);
67641                 return -1;
67642             }
67643         } // getOperandSize
67644
67645         bool
67646         isSrcOperand(int opIdx) override
67647         {
67648             switch (opIdx) {
67649               case 0: //vgpr_s
67650                 return true;
67651               case 1: //vgpr_a
67652                 return true;
67653               case 2: //sgpr_r
67654                 return true;
67655               case 3: //sgpr_o
67656                 return true;
67657               default:
67658                 fatal("op idx %i out of bounds\n", opIdx);
67659                 return false;
67660             }
67661         } // isSrcOperand
67662
67663         bool
67664         isDstOperand(int opIdx) override
67665         {
67666             switch (opIdx) {
67667               case 0: //vgpr_s
67668                 return false;
67669               case 1: //vgpr_a
67670                 return false;
67671               case 2: //sgpr_r
67672                 return false;
67673               case 3: //sgpr_o
67674                 return false;
67675               default:
67676                 fatal("op idx %i out of bounds\n", opIdx);
67677                 return false;
67678             }
67679         } // isDstOperand
67680
67681         void execute(GPUDynInstPtr) override;
67682         void initiateAcc(GPUDynInstPtr) override;
67683         void completeAcc(GPUDynInstPtr) override;
67684     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_XY
67685
67686     class Inst_MUBUF__BUFFER_STORE_FORMAT_XYZ : public Inst_MUBUF
67687     {
67688       public:
67689         Inst_MUBUF__BUFFER_STORE_FORMAT_XYZ(InFmt_MUBUF*);
67690         ~Inst_MUBUF__BUFFER_STORE_FORMAT_XYZ();
67691
67692         int
67693         getNumOperands() override
67694         {
67695             return numDstRegOperands() + numSrcRegOperands();
67696         } // getNumOperands
67697
67698         int numDstRegOperands() override { return 0; }
67699         int numSrcRegOperands() override { return 4; }
67700
67701         int
67702         getOperandSize(int opIdx) override
67703         {
67704             switch (opIdx) {
67705               case 0: //vgpr_s
67706                 return 12;
67707               case 1: //vgpr_a
67708                 return 8;
67709               case 2: //sgpr_r
67710                 return 4;
67711               case 3: //sgpr_o
67712                 return 4;
67713               default:
67714                 fatal("op idx %i out of bounds\n", opIdx);
67715                 return -1;
67716             }
67717         } // getOperandSize
67718
67719         bool
67720         isSrcOperand(int opIdx) override
67721         {
67722             switch (opIdx) {
67723               case 0: //vgpr_s
67724                 return true;
67725               case 1: //vgpr_a
67726                 return true;
67727               case 2: //sgpr_r
67728                 return true;
67729               case 3: //sgpr_o
67730                 return true;
67731               default:
67732                 fatal("op idx %i out of bounds\n", opIdx);
67733                 return false;
67734             }
67735         } // isSrcOperand
67736
67737         bool
67738         isDstOperand(int opIdx) override
67739         {
67740             switch (opIdx) {
67741               case 0: //vgpr_s
67742                 return false;
67743               case 1: //vgpr_a
67744                 return false;
67745               case 2: //sgpr_r
67746                 return false;
67747               case 3: //sgpr_o
67748                 return false;
67749               default:
67750                 fatal("op idx %i out of bounds\n", opIdx);
67751                 return false;
67752             }
67753         } // isDstOperand
67754
67755         void execute(GPUDynInstPtr) override;
67756         void initiateAcc(GPUDynInstPtr) override;
67757         void completeAcc(GPUDynInstPtr) override;
67758     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_XYZ
67759
67760     class Inst_MUBUF__BUFFER_STORE_FORMAT_XYZW : public Inst_MUBUF
67761     {
67762       public:
67763         Inst_MUBUF__BUFFER_STORE_FORMAT_XYZW(InFmt_MUBUF*);
67764         ~Inst_MUBUF__BUFFER_STORE_FORMAT_XYZW();
67765
67766         int
67767         getNumOperands() override
67768         {
67769             return numDstRegOperands() + numSrcRegOperands();
67770         } // getNumOperands
67771
67772         int numDstRegOperands() override { return 0; }
67773         int numSrcRegOperands() override { return 4; }
67774
67775         int
67776         getOperandSize(int opIdx) override
67777         {
67778             switch (opIdx) {
67779               case 0: //vgpr_s
67780                 return 16;
67781               case 1: //vgpr_a
67782                 return 8;
67783               case 2: //sgpr_r
67784                 return 4;
67785               case 3: //sgpr_o
67786                 return 4;
67787               default:
67788                 fatal("op idx %i out of bounds\n", opIdx);
67789                 return -1;
67790             }
67791         } // getOperandSize
67792
67793         bool
67794         isSrcOperand(int opIdx) override
67795         {
67796             switch (opIdx) {
67797               case 0: //vgpr_s
67798                 return true;
67799               case 1: //vgpr_a
67800                 return true;
67801               case 2: //sgpr_r
67802                 return true;
67803               case 3: //sgpr_o
67804                 return true;
67805               default:
67806                 fatal("op idx %i out of bounds\n", opIdx);
67807                 return false;
67808             }
67809         } // isSrcOperand
67810
67811         bool
67812         isDstOperand(int opIdx) override
67813         {
67814             switch (opIdx) {
67815               case 0: //vgpr_s
67816                 return false;
67817               case 1: //vgpr_a
67818                 return false;
67819               case 2: //sgpr_r
67820                 return false;
67821               case 3: //sgpr_o
67822                 return false;
67823               default:
67824                 fatal("op idx %i out of bounds\n", opIdx);
67825                 return false;
67826             }
67827         } // isDstOperand
67828
67829         void execute(GPUDynInstPtr) override;
67830         void initiateAcc(GPUDynInstPtr) override;
67831         void completeAcc(GPUDynInstPtr) override;
67832     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_XYZW
67833
67834     class Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_X : public Inst_MUBUF
67835     {
67836       public:
67837         Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_X(InFmt_MUBUF*);
67838         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_X();
67839
67840         int
67841         getNumOperands() override
67842         {
67843             return numDstRegOperands() + numSrcRegOperands();
67844         } // getNumOperands
67845
67846         int numDstRegOperands() override { return 1; }
67847         int numSrcRegOperands() override { return 3; }
67848
67849         int
67850         getOperandSize(int opIdx) override
67851         {
67852             switch (opIdx) {
67853               case 0: //vgpr_a
67854                 return 8;
67855               case 1: //sgpr_r
67856                 return 4;
67857               case 2: //sgpr_o
67858                 return 4;
67859               case 3: //vgpr_d
67860                 return 4;
67861               default:
67862                 fatal("op idx %i out of bounds\n", opIdx);
67863                 return -1;
67864             }
67865         } // getOperandSize
67866
67867         bool
67868         isSrcOperand(int opIdx) override
67869         {
67870             switch (opIdx) {
67871               case 0: //vgpr_a
67872                 return true;
67873               case 1: //sgpr_r
67874                 return true;
67875               case 2: //sgpr_o
67876                 return true;
67877               case 3: //vgpr_d
67878                 return false;
67879               default:
67880                 fatal("op idx %i out of bounds\n", opIdx);
67881                 return false;
67882             }
67883         } // isSrcOperand
67884
67885         bool
67886         isDstOperand(int opIdx) override
67887         {
67888             switch (opIdx) {
67889               case 0: //vgpr_a
67890                 return false;
67891               case 1: //sgpr_r
67892                 return false;
67893               case 2: //sgpr_o
67894                 return false;
67895               case 3: //vgpr_d
67896                 return true;
67897               default:
67898                 fatal("op idx %i out of bounds\n", opIdx);
67899                 return false;
67900             }
67901         } // isDstOperand
67902
67903         void execute(GPUDynInstPtr) override;
67904         void initiateAcc(GPUDynInstPtr) override;
67905         void completeAcc(GPUDynInstPtr) override;
67906     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_X
67907
67908     class Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XY : public Inst_MUBUF
67909     {
67910       public:
67911         Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XY(InFmt_MUBUF*);
67912         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XY();
67913
67914         int
67915         getNumOperands() override
67916         {
67917             return numDstRegOperands() + numSrcRegOperands();
67918         } // getNumOperands
67919
67920         int numDstRegOperands() override { return 1; }
67921         int numSrcRegOperands() override { return 3; }
67922
67923         int
67924         getOperandSize(int opIdx) override
67925         {
67926             switch (opIdx) {
67927               case 0: //vgpr_a
67928                 return 8;
67929               case 1: //sgpr_r
67930                 return 4;
67931               case 2: //sgpr_o
67932                 return 4;
67933               case 3: //vgpr_d
67934                 return 8;
67935               default:
67936                 fatal("op idx %i out of bounds\n", opIdx);
67937                 return -1;
67938             }
67939         } // getOperandSize
67940
67941         bool
67942         isSrcOperand(int opIdx) override
67943         {
67944             switch (opIdx) {
67945               case 0: //vgpr_a
67946                 return true;
67947               case 1: //sgpr_r
67948                 return true;
67949               case 2: //sgpr_o
67950                 return true;
67951               case 3: //vgpr_d
67952                 return false;
67953               default:
67954                 fatal("op idx %i out of bounds\n", opIdx);
67955                 return false;
67956             }
67957         } // isSrcOperand
67958
67959         bool
67960         isDstOperand(int opIdx) override
67961         {
67962             switch (opIdx) {
67963               case 0: //vgpr_a
67964                 return false;
67965               case 1: //sgpr_r
67966                 return false;
67967               case 2: //sgpr_o
67968                 return false;
67969               case 3: //vgpr_d
67970                 return true;
67971               default:
67972                 fatal("op idx %i out of bounds\n", opIdx);
67973                 return false;
67974             }
67975         } // isDstOperand
67976
67977         void execute(GPUDynInstPtr) override;
67978         void initiateAcc(GPUDynInstPtr) override;
67979         void completeAcc(GPUDynInstPtr) override;
67980     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XY
67981
67982     class Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZ : public Inst_MUBUF
67983     {
67984       public:
67985         Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZ(InFmt_MUBUF*);
67986         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZ();
67987
67988         int
67989         getNumOperands() override
67990         {
67991             return numDstRegOperands() + numSrcRegOperands();
67992         } // getNumOperands
67993
67994         int numDstRegOperands() override { return 1; }
67995         int numSrcRegOperands() override { return 3; }
67996
67997         int
67998         getOperandSize(int opIdx) override
67999         {
68000             switch (opIdx) {
68001               case 0: //vgpr_a
68002                 return 8;
68003               case 1: //sgpr_r
68004                 return 4;
68005               case 2: //sgpr_o
68006                 return 4;
68007               case 3: //vgpr_d
68008                 return 12;
68009               default:
68010                 fatal("op idx %i out of bounds\n", opIdx);
68011                 return -1;
68012             }
68013         } // getOperandSize
68014
68015         bool
68016         isSrcOperand(int opIdx) override
68017         {
68018             switch (opIdx) {
68019               case 0: //vgpr_a
68020                 return true;
68021               case 1: //sgpr_r
68022                 return true;
68023               case 2: //sgpr_o
68024                 return true;
68025               case 3: //vgpr_d
68026                 return false;
68027               default:
68028                 fatal("op idx %i out of bounds\n", opIdx);
68029                 return false;
68030             }
68031         } // isSrcOperand
68032
68033         bool
68034         isDstOperand(int opIdx) override
68035         {
68036             switch (opIdx) {
68037               case 0: //vgpr_a
68038                 return false;
68039               case 1: //sgpr_r
68040                 return false;
68041               case 2: //sgpr_o
68042                 return false;
68043               case 3: //vgpr_d
68044                 return true;
68045               default:
68046                 fatal("op idx %i out of bounds\n", opIdx);
68047                 return false;
68048             }
68049         } // isDstOperand
68050
68051         void execute(GPUDynInstPtr) override;
68052         void initiateAcc(GPUDynInstPtr) override;
68053         void completeAcc(GPUDynInstPtr) override;
68054     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZ
68055
68056     class Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZW : public Inst_MUBUF
68057     {
68058       public:
68059         Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZW(InFmt_MUBUF*);
68060         ~Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZW();
68061
68062         int
68063         getNumOperands() override
68064         {
68065             return numDstRegOperands() + numSrcRegOperands();
68066         } // getNumOperands
68067
68068         int numDstRegOperands() override { return 1; }
68069         int numSrcRegOperands() override { return 3; }
68070
68071         int
68072         getOperandSize(int opIdx) override
68073         {
68074             switch (opIdx) {
68075               case 0: //vgpr_a
68076                 return 8;
68077               case 1: //sgpr_r
68078                 return 4;
68079               case 2: //sgpr_o
68080                 return 4;
68081               case 3: //vgpr_d
68082                 return 16;
68083               default:
68084                 fatal("op idx %i out of bounds\n", opIdx);
68085                 return -1;
68086             }
68087         } // getOperandSize
68088
68089         bool
68090         isSrcOperand(int opIdx) override
68091         {
68092             switch (opIdx) {
68093               case 0: //vgpr_a
68094                 return true;
68095               case 1: //sgpr_r
68096                 return true;
68097               case 2: //sgpr_o
68098                 return true;
68099               case 3: //vgpr_d
68100                 return false;
68101               default:
68102                 fatal("op idx %i out of bounds\n", opIdx);
68103                 return false;
68104             }
68105         } // isSrcOperand
68106
68107         bool
68108         isDstOperand(int opIdx) override
68109         {
68110             switch (opIdx) {
68111               case 0: //vgpr_a
68112                 return false;
68113               case 1: //sgpr_r
68114                 return false;
68115               case 2: //sgpr_o
68116                 return false;
68117               case 3: //vgpr_d
68118                 return true;
68119               default:
68120                 fatal("op idx %i out of bounds\n", opIdx);
68121                 return false;
68122             }
68123         } // isDstOperand
68124
68125         void execute(GPUDynInstPtr) override;
68126         void initiateAcc(GPUDynInstPtr) override;
68127         void completeAcc(GPUDynInstPtr) override;
68128     }; // Inst_MUBUF__BUFFER_LOAD_FORMAT_D16_XYZW
68129
68130     class Inst_MUBUF__BUFFER_STORE_FORMAT_D16_X : public Inst_MUBUF
68131     {
68132       public:
68133         Inst_MUBUF__BUFFER_STORE_FORMAT_D16_X(InFmt_MUBUF*);
68134         ~Inst_MUBUF__BUFFER_STORE_FORMAT_D16_X();
68135
68136         int
68137         getNumOperands() override
68138         {
68139             return numDstRegOperands() + numSrcRegOperands();
68140         } // getNumOperands
68141
68142         int numDstRegOperands() override { return 0; }
68143         int numSrcRegOperands() override { return 4; }
68144
68145         int
68146         getOperandSize(int opIdx) override
68147         {
68148             switch (opIdx) {
68149               case 0: //vgpr_s
68150                 return 4;
68151               case 1: //vgpr_a
68152                 return 8;
68153               case 2: //sgpr_r
68154                 return 4;
68155               case 3: //sgpr_o
68156                 return 4;
68157               default:
68158                 fatal("op idx %i out of bounds\n", opIdx);
68159                 return -1;
68160             }
68161         } // getOperandSize
68162
68163         bool
68164         isSrcOperand(int opIdx) override
68165         {
68166             switch (opIdx) {
68167               case 0: //vgpr_s
68168                 return true;
68169               case 1: //vgpr_a
68170                 return true;
68171               case 2: //sgpr_r
68172                 return true;
68173               case 3: //sgpr_o
68174                 return true;
68175               default:
68176                 fatal("op idx %i out of bounds\n", opIdx);
68177                 return false;
68178             }
68179         } // isSrcOperand
68180
68181         bool
68182         isDstOperand(int opIdx) override
68183         {
68184             switch (opIdx) {
68185               case 0: //vgpr_s
68186                 return false;
68187               case 1: //vgpr_a
68188                 return false;
68189               case 2: //sgpr_r
68190                 return false;
68191               case 3: //sgpr_o
68192                 return false;
68193               default:
68194                 fatal("op idx %i out of bounds\n", opIdx);
68195                 return false;
68196             }
68197         } // isDstOperand
68198
68199         void execute(GPUDynInstPtr) override;
68200         void initiateAcc(GPUDynInstPtr) override;
68201         void completeAcc(GPUDynInstPtr) override;
68202     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_D16_X
68203
68204     class Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XY : public Inst_MUBUF
68205     {
68206       public:
68207         Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XY(InFmt_MUBUF*);
68208         ~Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XY();
68209
68210         int
68211         getNumOperands() override
68212         {
68213             return numDstRegOperands() + numSrcRegOperands();
68214         } // getNumOperands
68215
68216         int numDstRegOperands() override { return 0; }
68217         int numSrcRegOperands() override { return 4; }
68218
68219         int
68220         getOperandSize(int opIdx) override
68221         {
68222             switch (opIdx) {
68223               case 0: //vgpr_s
68224                 return 8;
68225               case 1: //vgpr_a
68226                 return 8;
68227               case 2: //sgpr_r
68228                 return 4;
68229               case 3: //sgpr_o
68230                 return 4;
68231               default:
68232                 fatal("op idx %i out of bounds\n", opIdx);
68233                 return -1;
68234             }
68235         } // getOperandSize
68236
68237         bool
68238         isSrcOperand(int opIdx) override
68239         {
68240             switch (opIdx) {
68241               case 0: //vgpr_s
68242                 return true;
68243               case 1: //vgpr_a
68244                 return true;
68245               case 2: //sgpr_r
68246                 return true;
68247               case 3: //sgpr_o
68248                 return true;
68249               default:
68250                 fatal("op idx %i out of bounds\n", opIdx);
68251                 return false;
68252             }
68253         } // isSrcOperand
68254
68255         bool
68256         isDstOperand(int opIdx) override
68257         {
68258             switch (opIdx) {
68259               case 0: //vgpr_s
68260                 return false;
68261               case 1: //vgpr_a
68262                 return false;
68263               case 2: //sgpr_r
68264                 return false;
68265               case 3: //sgpr_o
68266                 return false;
68267               default:
68268                 fatal("op idx %i out of bounds\n", opIdx);
68269                 return false;
68270             }
68271         } // isDstOperand
68272
68273         void execute(GPUDynInstPtr) override;
68274         void initiateAcc(GPUDynInstPtr) override;
68275         void completeAcc(GPUDynInstPtr) override;
68276     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XY
68277
68278     class Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZ : public Inst_MUBUF
68279     {
68280       public:
68281         Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZ(InFmt_MUBUF*);
68282         ~Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZ();
68283
68284         int
68285         getNumOperands() override
68286         {
68287             return numDstRegOperands() + numSrcRegOperands();
68288         } // getNumOperands
68289
68290         int numDstRegOperands() override { return 0; }
68291         int numSrcRegOperands() override { return 4; }
68292
68293         int
68294         getOperandSize(int opIdx) override
68295         {
68296             switch (opIdx) {
68297               case 0: //vgpr_s
68298                 return 12;
68299               case 1: //vgpr_a
68300                 return 8;
68301               case 2: //sgpr_r
68302                 return 4;
68303               case 3: //sgpr_o
68304                 return 4;
68305               default:
68306                 fatal("op idx %i out of bounds\n", opIdx);
68307                 return -1;
68308             }
68309         } // getOperandSize
68310
68311         bool
68312         isSrcOperand(int opIdx) override
68313         {
68314             switch (opIdx) {
68315               case 0: //vgpr_s
68316                 return true;
68317               case 1: //vgpr_a
68318                 return true;
68319               case 2: //sgpr_r
68320                 return true;
68321               case 3: //sgpr_o
68322                 return true;
68323               default:
68324                 fatal("op idx %i out of bounds\n", opIdx);
68325                 return false;
68326             }
68327         } // isSrcOperand
68328
68329         bool
68330         isDstOperand(int opIdx) override
68331         {
68332             switch (opIdx) {
68333               case 0: //vgpr_s
68334                 return false;
68335               case 1: //vgpr_a
68336                 return false;
68337               case 2: //sgpr_r
68338                 return false;
68339               case 3: //sgpr_o
68340                 return false;
68341               default:
68342                 fatal("op idx %i out of bounds\n", opIdx);
68343                 return false;
68344             }
68345         } // isDstOperand
68346
68347         void execute(GPUDynInstPtr) override;
68348         void initiateAcc(GPUDynInstPtr) override;
68349         void completeAcc(GPUDynInstPtr) override;
68350     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZ
68351
68352     class Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZW : public Inst_MUBUF
68353     {
68354       public:
68355         Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZW(InFmt_MUBUF*);
68356         ~Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZW();
68357
68358         int
68359         getNumOperands() override
68360         {
68361             return numDstRegOperands() + numSrcRegOperands();
68362         } // getNumOperands
68363
68364         int numDstRegOperands() override { return 0; }
68365         int numSrcRegOperands() override { return 4; }
68366
68367         int
68368         getOperandSize(int opIdx) override
68369         {
68370             switch (opIdx) {
68371               case 0: //vgpr_s
68372                 return 16;
68373               case 1: //vgpr_a
68374                 return 8;
68375               case 2: //sgpr_r
68376                 return 4;
68377               case 3: //sgpr_o
68378                 return 4;
68379               default:
68380                 fatal("op idx %i out of bounds\n", opIdx);
68381                 return -1;
68382             }
68383         } // getOperandSize
68384
68385         bool
68386         isSrcOperand(int opIdx) override
68387         {
68388             switch (opIdx) {
68389               case 0: //vgpr_s
68390                 return true;
68391               case 1: //vgpr_a
68392                 return true;
68393               case 2: //sgpr_r
68394                 return true;
68395               case 3: //sgpr_o
68396                 return true;
68397               default:
68398                 fatal("op idx %i out of bounds\n", opIdx);
68399                 return false;
68400             }
68401         } // isSrcOperand
68402
68403         bool
68404         isDstOperand(int opIdx) override
68405         {
68406             switch (opIdx) {
68407               case 0: //vgpr_s
68408                 return false;
68409               case 1: //vgpr_a
68410                 return false;
68411               case 2: //sgpr_r
68412                 return false;
68413               case 3: //sgpr_o
68414                 return false;
68415               default:
68416                 fatal("op idx %i out of bounds\n", opIdx);
68417                 return false;
68418             }
68419         } // isDstOperand
68420
68421         void execute(GPUDynInstPtr) override;
68422         void initiateAcc(GPUDynInstPtr) override;
68423         void completeAcc(GPUDynInstPtr) override;
68424     }; // Inst_MUBUF__BUFFER_STORE_FORMAT_D16_XYZW
68425
68426     class Inst_MUBUF__BUFFER_LOAD_UBYTE : public Inst_MUBUF
68427     {
68428       public:
68429         Inst_MUBUF__BUFFER_LOAD_UBYTE(InFmt_MUBUF*);
68430         ~Inst_MUBUF__BUFFER_LOAD_UBYTE();
68431
68432         int
68433         getNumOperands() override
68434         {
68435             return numDstRegOperands() + numSrcRegOperands();
68436         } // getNumOperands
68437
68438         int numDstRegOperands() override { return 1; }
68439         int numSrcRegOperands() override { return 3; }
68440
68441         int
68442         getOperandSize(int opIdx) override
68443         {
68444             switch (opIdx) {
68445               case 0: //vgpr_d
68446                 return 4;
68447               case 1: //vgpr_a
68448                 if (instData.OFFEN && instData.IDXEN) {
68449                     // if we need an idx and offset from a
68450                     // VGPR, we'll read VGPR[VADDR] and
68451                     // VGPR[VADDR + 1], otherwise we just
68452                     // read VGPR[VADDR]
68453                     return 8;
68454                 } else {
68455                     return 4;
68456                 }
68457               case 2: //sgpr_r
68458                 return 16;
68459               case 3: //sgpr_o
68460                 return 4;
68461               default:
68462                 fatal("op idx %i out of bounds\n", opIdx);
68463                 return -1;
68464             }
68465         } // getOperandSize
68466
68467         bool
68468         isSrcOperand(int opIdx) override
68469         {
68470             switch (opIdx) {
68471               case 0: //vgpr_d
68472                 return false;
68473               case 1: //vgpr_a
68474                 return true;
68475               case 2: //sgpr_r
68476                 return true;
68477               case 3: //sgpr_o
68478                 return true;
68479               default:
68480                 fatal("op idx %i out of bounds\n", opIdx);
68481                 return false;
68482             }
68483         } // isSrcOperand
68484
68485         bool
68486         isDstOperand(int opIdx) override
68487         {
68488             switch (opIdx) {
68489               case 0: //vgpr_d
68490                 return true;
68491               case 1: //vgpr_a
68492                 return false;
68493               case 2: //sgpr_r
68494                 return false;
68495               case 3: //sgpr_o
68496                 return false;
68497               default:
68498                 fatal("op idx %i out of bounds\n", opIdx);
68499                 return false;
68500             }
68501         } // isDstOperand
68502
68503         void execute(GPUDynInstPtr) override;
68504         void initiateAcc(GPUDynInstPtr) override;
68505         void completeAcc(GPUDynInstPtr) override;
68506     }; // Inst_MUBUF__BUFFER_LOAD_UBYTE
68507
68508     class Inst_MUBUF__BUFFER_LOAD_SBYTE : public Inst_MUBUF
68509     {
68510       public:
68511         Inst_MUBUF__BUFFER_LOAD_SBYTE(InFmt_MUBUF*);
68512         ~Inst_MUBUF__BUFFER_LOAD_SBYTE();
68513
68514         int
68515         getNumOperands() override
68516         {
68517             return numDstRegOperands() + numSrcRegOperands();
68518         } // getNumOperands
68519
68520         int numDstRegOperands() override { return 1; }
68521         int numSrcRegOperands() override { return 3; }
68522
68523         int
68524         getOperandSize(int opIdx) override
68525         {
68526             switch (opIdx) {
68527               case 0: //vgpr_a
68528                 return 8;
68529               case 1: //sgpr_r
68530                 return 16;
68531               case 2: //sgpr_o
68532                 return 4;
68533               case 3: //vgpr_d
68534                 return 4;
68535               default:
68536                 fatal("op idx %i out of bounds\n", opIdx);
68537                 return -1;
68538             }
68539         } // getOperandSize
68540
68541         bool
68542         isSrcOperand(int opIdx) override
68543         {
68544             switch (opIdx) {
68545               case 0: //vgpr_a
68546                 return true;
68547               case 1: //sgpr_r
68548                 return true;
68549               case 2: //sgpr_o
68550                 return true;
68551               case 3: //vgpr_d
68552                 return false;
68553               default:
68554                 fatal("op idx %i out of bounds\n", opIdx);
68555                 return false;
68556             }
68557         } // isSrcOperand
68558
68559         bool
68560         isDstOperand(int opIdx) override
68561         {
68562             switch (opIdx) {
68563               case 0: //vgpr_a
68564                 return false;
68565               case 1: //sgpr_r
68566                 return false;
68567               case 2: //sgpr_o
68568                 return false;
68569               case 3: //vgpr_d
68570                 return true;
68571               default:
68572                 fatal("op idx %i out of bounds\n", opIdx);
68573                 return false;
68574             }
68575         } // isDstOperand
68576
68577         void execute(GPUDynInstPtr) override;
68578         void initiateAcc(GPUDynInstPtr) override;
68579         void completeAcc(GPUDynInstPtr) override;
68580     }; // Inst_MUBUF__BUFFER_LOAD_SBYTE
68581
68582     class Inst_MUBUF__BUFFER_LOAD_USHORT : public Inst_MUBUF
68583     {
68584       public:
68585         Inst_MUBUF__BUFFER_LOAD_USHORT(InFmt_MUBUF*);
68586         ~Inst_MUBUF__BUFFER_LOAD_USHORT();
68587
68588         int
68589         getNumOperands() override
68590         {
68591             return numDstRegOperands() + numSrcRegOperands();
68592         } // getNumOperands
68593
68594         int numDstRegOperands() override { return 1; }
68595         int numSrcRegOperands() override { return 3; }
68596
68597         int
68598         getOperandSize(int opIdx) override
68599         {
68600             switch (opIdx) {
68601               case 0: //vgpr_a
68602                 return 8;
68603               case 1: //sgpr_r
68604                 return 16;
68605               case 2: //sgpr_o
68606                 return 4;
68607               case 3: //vgpr_d
68608                 return 4;
68609               default:
68610                 fatal("op idx %i out of bounds\n", opIdx);
68611                 return -1;
68612             }
68613         } // getOperandSize
68614
68615         bool
68616         isSrcOperand(int opIdx) override
68617         {
68618             switch (opIdx) {
68619               case 0: //vgpr_a
68620                 return true;
68621               case 1: //sgpr_r
68622                 return true;
68623               case 2: //sgpr_o
68624                 return true;
68625               case 3: //vgpr_d
68626                 return false;
68627               default:
68628                 fatal("op idx %i out of bounds\n", opIdx);
68629                 return false;
68630             }
68631         } // isSrcOperand
68632
68633         bool
68634         isDstOperand(int opIdx) override
68635         {
68636             switch (opIdx) {
68637               case 0: //vgpr_a
68638                 return false;
68639               case 1: //sgpr_r
68640                 return false;
68641               case 2: //sgpr_o
68642                 return false;
68643               case 3: //vgpr_d
68644                 return true;
68645               default:
68646                 fatal("op idx %i out of bounds\n", opIdx);
68647                 return false;
68648             }
68649         } // isDstOperand
68650
68651         void execute(GPUDynInstPtr) override;
68652         void initiateAcc(GPUDynInstPtr) override;
68653         void completeAcc(GPUDynInstPtr) override;
68654     }; // Inst_MUBUF__BUFFER_LOAD_USHORT
68655
68656     class Inst_MUBUF__BUFFER_LOAD_SSHORT : public Inst_MUBUF
68657     {
68658       public:
68659         Inst_MUBUF__BUFFER_LOAD_SSHORT(InFmt_MUBUF*);
68660         ~Inst_MUBUF__BUFFER_LOAD_SSHORT();
68661
68662         int
68663         getNumOperands() override
68664         {
68665             return numDstRegOperands() + numSrcRegOperands();
68666         } // getNumOperands
68667
68668         int numDstRegOperands() override { return 1; }
68669         int numSrcRegOperands() override { return 3; }
68670
68671         int
68672         getOperandSize(int opIdx) override
68673         {
68674             switch (opIdx) {
68675               case 0: //vgpr_a
68676                 return 8;
68677               case 1: //sgpr_r
68678                 return 16;
68679               case 2: //sgpr_o
68680                 return 4;
68681               case 3: //vgpr_d
68682                 return 32;
68683               default:
68684                 fatal("op idx %i out of bounds\n", opIdx);
68685                 return -1;
68686             }
68687         } // getOperandSize
68688
68689         bool
68690         isSrcOperand(int opIdx) override
68691         {
68692             switch (opIdx) {
68693               case 0: //vgpr_a
68694                 return true;
68695               case 1: //sgpr_r
68696                 return true;
68697               case 2: //sgpr_o
68698                 return true;
68699               case 3: //vgpr_d
68700                 return false;
68701               default:
68702                 fatal("op idx %i out of bounds\n", opIdx);
68703                 return false;
68704             }
68705         } // isSrcOperand
68706
68707         bool
68708         isDstOperand(int opIdx) override
68709         {
68710             switch (opIdx) {
68711               case 0: //vgpr_a
68712                 return false;
68713               case 1: //sgpr_r
68714                 return false;
68715               case 2: //sgpr_o
68716                 return false;
68717               case 3: //vgpr_d
68718                 return true;
68719               default:
68720                 fatal("op idx %i out of bounds\n", opIdx);
68721                 return false;
68722             }
68723         } // isDstOperand
68724
68725         void execute(GPUDynInstPtr) override;
68726         void initiateAcc(GPUDynInstPtr) override;
68727         void completeAcc(GPUDynInstPtr) override;
68728     }; // Inst_MUBUF__BUFFER_LOAD_SSHORT
68729
68730     class Inst_MUBUF__BUFFER_LOAD_DWORD : public Inst_MUBUF
68731     {
68732       public:
68733         Inst_MUBUF__BUFFER_LOAD_DWORD(InFmt_MUBUF*);
68734         ~Inst_MUBUF__BUFFER_LOAD_DWORD();
68735
68736         int
68737         getNumOperands() override
68738         {
68739             return numDstRegOperands() + numSrcRegOperands();
68740         } // getNumOperands
68741
68742         int numDstRegOperands() override { return 1; }
68743         int numSrcRegOperands() override { return 3; }
68744
68745         int
68746         getOperandSize(int opIdx) override
68747         {
68748             switch (opIdx) {
68749               case 0: //vgpr_a
68750                 return 8;
68751               case 1: //sgpr_r
68752                 return 16;
68753               case 2: //sgpr_o
68754                 return 4;
68755               case 3: //vgpr_d
68756                 return 4;
68757               default:
68758                 fatal("op idx %i out of bounds\n", opIdx);
68759                 return -1;
68760             }
68761         } // getOperandSize
68762
68763         bool
68764         isSrcOperand(int opIdx) override
68765         {
68766             switch (opIdx) {
68767               case 0: //vgpr_a
68768                 return true;
68769               case 1: //sgpr_r
68770                 return true;
68771               case 2: //sgpr_o
68772                 return true;
68773               case 3: //vgpr_d
68774                 return false;
68775               default:
68776                 fatal("op idx %i out of bounds\n", opIdx);
68777                 return false;
68778             }
68779         } // isSrcOperand
68780
68781         bool
68782         isDstOperand(int opIdx) override
68783         {
68784             switch (opIdx) {
68785               case 0: //vgpr_a
68786                 return false;
68787               case 1: //sgpr_r
68788                 return false;
68789               case 2: //sgpr_o
68790                 return false;
68791               case 3: //vgpr_d
68792                 return true;
68793               default:
68794                 fatal("op idx %i out of bounds\n", opIdx);
68795                 return false;
68796             }
68797         } // isDstOperand
68798
68799         void execute(GPUDynInstPtr) override;
68800         void initiateAcc(GPUDynInstPtr) override;
68801         void completeAcc(GPUDynInstPtr) override;
68802     }; // Inst_MUBUF__BUFFER_LOAD_DWORD
68803
68804     class Inst_MUBUF__BUFFER_LOAD_DWORDX2 : public Inst_MUBUF
68805     {
68806       public:
68807         Inst_MUBUF__BUFFER_LOAD_DWORDX2(InFmt_MUBUF*);
68808         ~Inst_MUBUF__BUFFER_LOAD_DWORDX2();
68809
68810         int
68811         getNumOperands() override
68812         {
68813             return numDstRegOperands() + numSrcRegOperands();
68814         } // getNumOperands
68815
68816         int numDstRegOperands() override { return 1; }
68817         int numSrcRegOperands() override { return 3; }
68818
68819         int
68820         getOperandSize(int opIdx) override
68821         {
68822             switch (opIdx) {
68823               case 0: //vgpr_a
68824                 return 8;
68825               case 1: //sgpr_r
68826                 return 16;
68827               case 2: //sgpr_o
68828                 return 4;
68829               case 3: //vgpr_d
68830                 return 8;
68831               default:
68832                 fatal("op idx %i out of bounds\n", opIdx);
68833                 return -1;
68834             }
68835         } // getOperandSize
68836
68837         bool
68838         isSrcOperand(int opIdx) override
68839         {
68840             switch (opIdx) {
68841               case 0: //vgpr_a
68842                 return true;
68843               case 1: //sgpr_r
68844                 return true;
68845               case 2: //sgpr_o
68846                 return true;
68847               case 3: //vgpr_d
68848                 return false;
68849               default:
68850                 fatal("op idx %i out of bounds\n", opIdx);
68851                 return false;
68852             }
68853         } // isSrcOperand
68854
68855         bool
68856         isDstOperand(int opIdx) override
68857         {
68858             switch (opIdx) {
68859               case 0: //vgpr_a
68860                 return false;
68861               case 1: //sgpr_r
68862                 return false;
68863               case 2: //sgpr_o
68864                 return false;
68865               case 3: //vgpr_d
68866                 return true;
68867               default:
68868                 fatal("op idx %i out of bounds\n", opIdx);
68869                 return false;
68870             }
68871         } // isDstOperand
68872
68873         void execute(GPUDynInstPtr) override;
68874         void initiateAcc(GPUDynInstPtr) override;
68875         void completeAcc(GPUDynInstPtr) override;
68876     }; // Inst_MUBUF__BUFFER_LOAD_DWORDX2
68877
68878     class Inst_MUBUF__BUFFER_LOAD_DWORDX3 : public Inst_MUBUF
68879     {
68880       public:
68881         Inst_MUBUF__BUFFER_LOAD_DWORDX3(InFmt_MUBUF*);
68882         ~Inst_MUBUF__BUFFER_LOAD_DWORDX3();
68883
68884         int
68885         getNumOperands() override
68886         {
68887             return numDstRegOperands() + numSrcRegOperands();
68888         } // getNumOperands
68889
68890         int numDstRegOperands() override { return 1; }
68891         int numSrcRegOperands() override { return 3; }
68892
68893         int
68894         getOperandSize(int opIdx) override
68895         {
68896             switch (opIdx) {
68897               case 0: //vgpr_a
68898                 return 8;
68899               case 1: //sgpr_r
68900                 return 16;
68901               case 2: //sgpr_o
68902                 return 4;
68903               case 3: //vgpr_d
68904                 return 12;
68905               default:
68906                 fatal("op idx %i out of bounds\n", opIdx);
68907                 return -1;
68908             }
68909         } // getOperandSize
68910
68911         bool
68912         isSrcOperand(int opIdx) override
68913         {
68914             switch (opIdx) {
68915               case 0: //vgpr_a
68916                 return true;
68917               case 1: //sgpr_r
68918                 return true;
68919               case 2: //sgpr_o
68920                 return true;
68921               case 3: //vgpr_d
68922                 return false;
68923               default:
68924                 fatal("op idx %i out of bounds\n", opIdx);
68925                 return false;
68926             }
68927         } // isSrcOperand
68928
68929         bool
68930         isDstOperand(int opIdx) override
68931         {
68932             switch (opIdx) {
68933               case 0: //vgpr_a
68934                 return false;
68935               case 1: //sgpr_r
68936                 return false;
68937               case 2: //sgpr_o
68938                 return false;
68939               case 3: //vgpr_d
68940                 return true;
68941               default:
68942                 fatal("op idx %i out of bounds\n", opIdx);
68943                 return false;
68944             }
68945         } // isDstOperand
68946
68947         void execute(GPUDynInstPtr) override;
68948         void initiateAcc(GPUDynInstPtr) override;
68949         void completeAcc(GPUDynInstPtr) override;
68950     }; // Inst_MUBUF__BUFFER_LOAD_DWORDX3
68951
68952     class Inst_MUBUF__BUFFER_LOAD_DWORDX4 : public Inst_MUBUF
68953     {
68954       public:
68955         Inst_MUBUF__BUFFER_LOAD_DWORDX4(InFmt_MUBUF*);
68956         ~Inst_MUBUF__BUFFER_LOAD_DWORDX4();
68957
68958         int
68959         getNumOperands() override
68960         {
68961             return numDstRegOperands() + numSrcRegOperands();
68962         } // getNumOperands
68963
68964         int numDstRegOperands() override { return 1; }
68965         int numSrcRegOperands() override { return 3; }
68966
68967         int
68968         getOperandSize(int opIdx) override
68969         {
68970             switch (opIdx) {
68971               case 0: //vgpr_a
68972                 return 8;
68973               case 1: //sgpr_r
68974                 return 16;
68975               case 2: //sgpr_o
68976                 return 4;
68977               case 3: //vgpr_d
68978                 return 16;
68979               default:
68980                 fatal("op idx %i out of bounds\n", opIdx);
68981                 return -1;
68982             }
68983         } // getOperandSize
68984
68985         bool
68986         isSrcOperand(int opIdx) override
68987         {
68988             switch (opIdx) {
68989               case 0: //vgpr_a
68990                 return true;
68991               case 1: //sgpr_r
68992                 return true;
68993               case 2: //sgpr_o
68994                 return true;
68995               case 3: //vgpr_d
68996                 return false;
68997               default:
68998                 fatal("op idx %i out of bounds\n", opIdx);
68999                 return false;
69000             }
69001         } // isSrcOperand
69002
69003         bool
69004         isDstOperand(int opIdx) override
69005         {
69006             switch (opIdx) {
69007               case 0: //vgpr_a
69008                 return false;
69009               case 1: //sgpr_r
69010                 return false;
69011               case 2: //sgpr_o
69012                 return false;
69013               case 3: //vgpr_d
69014                 return true;
69015               default:
69016                 fatal("op idx %i out of bounds\n", opIdx);
69017                 return false;
69018             }
69019         } // isDstOperand
69020
69021         void execute(GPUDynInstPtr) override;
69022         void initiateAcc(GPUDynInstPtr) override;
69023         void completeAcc(GPUDynInstPtr) override;
69024     }; // Inst_MUBUF__BUFFER_LOAD_DWORDX4
69025
69026     class Inst_MUBUF__BUFFER_STORE_BYTE : public Inst_MUBUF
69027     {
69028       public:
69029         Inst_MUBUF__BUFFER_STORE_BYTE(InFmt_MUBUF*);
69030         ~Inst_MUBUF__BUFFER_STORE_BYTE();
69031
69032         int
69033         getNumOperands() override
69034         {
69035             return numDstRegOperands() + numSrcRegOperands();
69036         } // getNumOperands
69037
69038         int numDstRegOperands() override { return 0; }
69039         int numSrcRegOperands() override { return 4; }
69040
69041         int
69042         getOperandSize(int opIdx) override
69043         {
69044             switch (opIdx) {
69045               case 0: //vgpr_s
69046                 return 4;
69047               case 1: //vgpr_a
69048                 if (instData.OFFEN && instData.IDXEN) {
69049                     // if we need an idx and offset from a
69050                     // VGPR, we'll read VGPR[VADDR] and
69051                     // VGPR[VADDR + 1], otherwise we just
69052                     // read VGPR[VADDR]
69053                     return 8;
69054                 } else {
69055                     return 4;
69056                 }
69057               case 2: //sgpr_r
69058                 return 16;
69059               case 3: //sgpr_o
69060                 return 4;
69061               default:
69062                 fatal("op idx %i out of bounds\n", opIdx);
69063                 return -1;
69064             }
69065         } // getOperandSize
69066
69067         bool
69068         isSrcOperand(int opIdx) override
69069         {
69070             switch (opIdx) {
69071               case 0: //vgpr_s
69072                 return true;
69073               case 1: //vgpr_a
69074                 return true;
69075               case 2: //sgpr_r
69076                 return true;
69077               case 3: //sgpr_o
69078                 return true;
69079               default:
69080                 fatal("op idx %i out of bounds\n", opIdx);
69081                 return false;
69082             }
69083         } // isSrcOperand
69084
69085         bool
69086         isDstOperand(int opIdx) override
69087         {
69088             switch (opIdx) {
69089               case 0: //vgpr_s
69090                 return false;
69091               case 1: //vgpr_a
69092                 return false;
69093               case 2: //sgpr_r
69094                 return false;
69095               case 3: //sgpr_o
69096                 return false;
69097               default:
69098                 fatal("op idx %i out of bounds\n", opIdx);
69099                 return false;
69100             }
69101         } // isDstOperand
69102
69103         void execute(GPUDynInstPtr) override;
69104         void initiateAcc(GPUDynInstPtr) override;
69105         void completeAcc(GPUDynInstPtr) override;
69106     }; // Inst_MUBUF__BUFFER_STORE_BYTE
69107
69108     class Inst_MUBUF__BUFFER_STORE_SHORT : public Inst_MUBUF
69109     {
69110       public:
69111         Inst_MUBUF__BUFFER_STORE_SHORT(InFmt_MUBUF*);
69112         ~Inst_MUBUF__BUFFER_STORE_SHORT();
69113
69114         int
69115         getNumOperands() override
69116         {
69117             return numDstRegOperands() + numSrcRegOperands();
69118         } // getNumOperands
69119
69120         int numDstRegOperands() override { return 0; }
69121         int numSrcRegOperands() override { return 4; }
69122
69123         int
69124         getOperandSize(int opIdx) override
69125         {
69126             switch (opIdx) {
69127               case 0: //vgpr_s
69128                 return 4;
69129               case 1: //vgpr_a
69130                 return 8;
69131               case 2: //sgpr_r
69132                 return 16;
69133               case 3: //sgpr_o
69134                 return 4;
69135               default:
69136                 fatal("op idx %i out of bounds\n", opIdx);
69137                 return -1;
69138             }
69139         } // getOperandSize
69140
69141         bool
69142         isSrcOperand(int opIdx) override
69143         {
69144             switch (opIdx) {
69145               case 0: //vgpr_s
69146                 return true;
69147               case 1: //vgpr_a
69148                 return true;
69149               case 2: //sgpr_r
69150                 return true;
69151               case 3: //sgpr_o
69152                 return true;
69153               default:
69154                 fatal("op idx %i out of bounds\n", opIdx);
69155                 return false;
69156             }
69157         } // isSrcOperand
69158
69159         bool
69160         isDstOperand(int opIdx) override
69161         {
69162             switch (opIdx) {
69163               case 0: //vgpr_s
69164                 return false;
69165               case 1: //vgpr_a
69166                 return false;
69167               case 2: //sgpr_r
69168                 return false;
69169               case 3: //sgpr_o
69170                 return false;
69171               default:
69172                 fatal("op idx %i out of bounds\n", opIdx);
69173                 return false;
69174             }
69175         } // isDstOperand
69176
69177         void execute(GPUDynInstPtr) override;
69178         void initiateAcc(GPUDynInstPtr) override;
69179         void completeAcc(GPUDynInstPtr) override;
69180     }; // Inst_MUBUF__BUFFER_STORE_SHORT
69181
69182     class Inst_MUBUF__BUFFER_STORE_DWORD : public Inst_MUBUF
69183     {
69184       public:
69185         Inst_MUBUF__BUFFER_STORE_DWORD(InFmt_MUBUF*);
69186         ~Inst_MUBUF__BUFFER_STORE_DWORD();
69187
69188         int
69189         getNumOperands() override
69190         {
69191             return numDstRegOperands() + numSrcRegOperands();
69192         } // getNumOperands
69193
69194         int numDstRegOperands() override { return 0; }
69195         int numSrcRegOperands() override { return 4; }
69196
69197         int
69198         getOperandSize(int opIdx) override
69199         {
69200             switch (opIdx) {
69201               case 0: //vgpr_s
69202                 return 4;
69203               case 1: //vgpr_a
69204                 return 8;
69205               case 2: //sgpr_r
69206                 return 16;
69207               case 3: //sgpr_o
69208                 return 4;
69209               default:
69210                 fatal("op idx %i out of bounds\n", opIdx);
69211                 return -1;
69212             }
69213         } // getOperandSize
69214
69215         bool
69216         isSrcOperand(int opIdx) override
69217         {
69218             switch (opIdx) {
69219               case 0: //vgpr_s
69220                 return true;
69221               case 1: //vgpr_a
69222                 return true;
69223               case 2: //sgpr_r
69224                 return true;
69225               case 3: //sgpr_o
69226                 return true;
69227               default:
69228                 fatal("op idx %i out of bounds\n", opIdx);
69229                 return false;
69230             }
69231         } // isSrcOperand
69232
69233         bool
69234         isDstOperand(int opIdx) override
69235         {
69236             switch (opIdx) {
69237               case 0: //vgpr_s
69238                 return false;
69239               case 1: //vgpr_a
69240                 return false;
69241               case 2: //sgpr_r
69242                 return false;
69243               case 3: //sgpr_o
69244                 return false;
69245               default:
69246                 fatal("op idx %i out of bounds\n", opIdx);
69247                 return false;
69248             }
69249         } // isDstOperand
69250
69251         void execute(GPUDynInstPtr) override;
69252         void initiateAcc(GPUDynInstPtr) override;
69253         void completeAcc(GPUDynInstPtr) override;
69254     }; // Inst_MUBUF__BUFFER_STORE_DWORD
69255
69256     class Inst_MUBUF__BUFFER_STORE_DWORDX2 : public Inst_MUBUF
69257     {
69258       public:
69259         Inst_MUBUF__BUFFER_STORE_DWORDX2(InFmt_MUBUF*);
69260         ~Inst_MUBUF__BUFFER_STORE_DWORDX2();
69261
69262         int
69263         getNumOperands() override
69264         {
69265             return numDstRegOperands() + numSrcRegOperands();
69266         } // getNumOperands
69267
69268         int numDstRegOperands() override { return 0; }
69269         int numSrcRegOperands() override { return 4; }
69270
69271         int
69272         getOperandSize(int opIdx) override
69273         {
69274             switch (opIdx) {
69275               case 0: //vgpr_s
69276                 return 8;
69277               case 1: //vgpr_a
69278                 return 8;
69279               case 2: //sgpr_r
69280                 return 16;
69281               case 3: //sgpr_o
69282                 return 4;
69283               default:
69284                 fatal("op idx %i out of bounds\n", opIdx);
69285                 return -1;
69286             }
69287         } // getOperandSize
69288
69289         bool
69290         isSrcOperand(int opIdx) override
69291         {
69292             switch (opIdx) {
69293               case 0: //vgpr_s
69294                 return true;
69295               case 1: //vgpr_a
69296                 return true;
69297               case 2: //sgpr_r
69298                 return true;
69299               case 3: //sgpr_o
69300                 return true;
69301               default:
69302                 fatal("op idx %i out of bounds\n", opIdx);
69303                 return false;
69304             }
69305         } // isSrcOperand
69306
69307         bool
69308         isDstOperand(int opIdx) override
69309         {
69310             switch (opIdx) {
69311               case 0: //vgpr_s
69312                 return false;
69313               case 1: //vgpr_a
69314                 return false;
69315               case 2: //sgpr_r
69316                 return false;
69317               case 3: //sgpr_o
69318                 return false;
69319               default:
69320                 fatal("op idx %i out of bounds\n", opIdx);
69321                 return false;
69322             }
69323         } // isDstOperand
69324
69325         void execute(GPUDynInstPtr) override;
69326         void initiateAcc(GPUDynInstPtr) override;
69327         void completeAcc(GPUDynInstPtr) override;
69328     }; // Inst_MUBUF__BUFFER_STORE_DWORDX2
69329
69330     class Inst_MUBUF__BUFFER_STORE_DWORDX3 : public Inst_MUBUF
69331     {
69332       public:
69333         Inst_MUBUF__BUFFER_STORE_DWORDX3(InFmt_MUBUF*);
69334         ~Inst_MUBUF__BUFFER_STORE_DWORDX3();
69335
69336         int
69337         getNumOperands() override
69338         {
69339             return numDstRegOperands() + numSrcRegOperands();
69340         } // getNumOperands
69341
69342         int numDstRegOperands() override { return 0; }
69343         int numSrcRegOperands() override { return 4; }
69344
69345         int
69346         getOperandSize(int opIdx) override
69347         {
69348             switch (opIdx) {
69349               case 0: //vgpr_s
69350                 return 12;
69351               case 1: //vgpr_a
69352                 return 8;
69353               case 2: //sgpr_r
69354                 return 16;
69355               case 3: //sgpr_o
69356                 return 4;
69357               default:
69358                 fatal("op idx %i out of bounds\n", opIdx);
69359                 return -1;
69360             }
69361         } // getOperandSize
69362
69363         bool
69364         isSrcOperand(int opIdx) override
69365         {
69366             switch (opIdx) {
69367               case 0: //vgpr_s
69368                 return true;
69369               case 1: //vgpr_a
69370                 return true;
69371               case 2: //sgpr_r
69372                 return true;
69373               case 3: //sgpr_o
69374                 return true;
69375               default:
69376                 fatal("op idx %i out of bounds\n", opIdx);
69377                 return false;
69378             }
69379         } // isSrcOperand
69380
69381         bool
69382         isDstOperand(int opIdx) override
69383         {
69384             switch (opIdx) {
69385               case 0: //vgpr_s
69386                 return false;
69387               case 1: //vgpr_a
69388                 return false;
69389               case 2: //sgpr_r
69390                 return false;
69391               case 3: //sgpr_o
69392                 return false;
69393               default:
69394                 fatal("op idx %i out of bounds\n", opIdx);
69395                 return false;
69396             }
69397         } // isDstOperand
69398
69399         void execute(GPUDynInstPtr) override;
69400         void initiateAcc(GPUDynInstPtr) override;
69401         void completeAcc(GPUDynInstPtr) override;
69402     }; // Inst_MUBUF__BUFFER_STORE_DWORDX3
69403
69404     class Inst_MUBUF__BUFFER_STORE_DWORDX4 : public Inst_MUBUF
69405     {
69406       public:
69407         Inst_MUBUF__BUFFER_STORE_DWORDX4(InFmt_MUBUF*);
69408         ~Inst_MUBUF__BUFFER_STORE_DWORDX4();
69409
69410         int
69411         getNumOperands() override
69412         {
69413             return numDstRegOperands() + numSrcRegOperands();
69414         } // getNumOperands
69415
69416         int numDstRegOperands() override { return 0; }
69417         int numSrcRegOperands() override { return 4; }
69418
69419         int
69420         getOperandSize(int opIdx) override
69421         {
69422             switch (opIdx) {
69423               case 0: //vgpr_s
69424                 return 16;
69425               case 1: //vgpr_a
69426                 return 8;
69427               case 2: //sgpr_r
69428                 return 16;
69429               case 3: //sgpr_o
69430                 return 4;
69431               default:
69432                 fatal("op idx %i out of bounds\n", opIdx);
69433                 return -1;
69434             }
69435         } // getOperandSize
69436
69437         bool
69438         isSrcOperand(int opIdx) override
69439         {
69440             switch (opIdx) {
69441               case 0: //vgpr_s
69442                 return true;
69443               case 1: //vgpr_a
69444                 return true;
69445               case 2: //sgpr_r
69446                 return true;
69447               case 3: //sgpr_o
69448                 return true;
69449               default:
69450                 fatal("op idx %i out of bounds\n", opIdx);
69451                 return false;
69452             }
69453         } // isSrcOperand
69454
69455         bool
69456         isDstOperand(int opIdx) override
69457         {
69458             switch (opIdx) {
69459               case 0: //vgpr_s
69460                 return false;
69461               case 1: //vgpr_a
69462                 return false;
69463               case 2: //sgpr_r
69464                 return false;
69465               case 3: //sgpr_o
69466                 return false;
69467               default:
69468                 fatal("op idx %i out of bounds\n", opIdx);
69469                 return false;
69470             }
69471         } // isDstOperand
69472
69473         void execute(GPUDynInstPtr) override;
69474         void initiateAcc(GPUDynInstPtr) override;
69475         void completeAcc(GPUDynInstPtr) override;
69476     }; // Inst_MUBUF__BUFFER_STORE_DWORDX4
69477
69478     class Inst_MUBUF__BUFFER_STORE_LDS_DWORD : public Inst_MUBUF
69479     {
69480       public:
69481         Inst_MUBUF__BUFFER_STORE_LDS_DWORD(InFmt_MUBUF*);
69482         ~Inst_MUBUF__BUFFER_STORE_LDS_DWORD();
69483
69484         int
69485         getNumOperands() override
69486         {
69487             return numDstRegOperands() + numSrcRegOperands();
69488         } // getNumOperands
69489
69490         int numDstRegOperands() override { return 0; }
69491         int numSrcRegOperands() override { return 2; }
69492
69493         int
69494         getOperandSize(int opIdx) override
69495         {
69496             switch (opIdx) {
69497               case 0: //sgpr_r
69498                 return 16;
69499               case 1: //sgpr_o
69500                 return 4;
69501               default:
69502                 fatal("op idx %i out of bounds\n", opIdx);
69503                 return -1;
69504             }
69505         } // getOperandSize
69506
69507         bool
69508         isSrcOperand(int opIdx) override
69509         {
69510             switch (opIdx) {
69511               case 0: //sgpr_r
69512                 return true;
69513               case 1: //sgpr_o
69514                 return true;
69515               default:
69516                 fatal("op idx %i out of bounds\n", opIdx);
69517                 return false;
69518             }
69519         } // isSrcOperand
69520
69521         bool
69522         isDstOperand(int opIdx) override
69523         {
69524             switch (opIdx) {
69525               case 0: //sgpr_r
69526                 return false;
69527               case 1: //sgpr_o
69528                 return false;
69529               default:
69530                 fatal("op idx %i out of bounds\n", opIdx);
69531                 return false;
69532             }
69533         } // isDstOperand
69534
69535         void execute(GPUDynInstPtr) override;
69536     }; // Inst_MUBUF__BUFFER_STORE_LDS_DWORD
69537
69538     class Inst_MUBUF__BUFFER_WBINVL1 : public Inst_MUBUF
69539     {
69540       public:
69541         Inst_MUBUF__BUFFER_WBINVL1(InFmt_MUBUF*);
69542         ~Inst_MUBUF__BUFFER_WBINVL1();
69543
69544         int
69545         getNumOperands() override
69546         {
69547             return numDstRegOperands() + numSrcRegOperands();
69548         } // getNumOperands
69549
69550         int numDstRegOperands() override { return 0; }
69551         int numSrcRegOperands() override { return 0; }
69552
69553         int
69554         getOperandSize(int opIdx) override
69555         {
69556             switch (opIdx) {
69557               default:
69558                 fatal("op idx %i out of bounds\n", opIdx);
69559                 return -1;
69560             }
69561         } // getOperandSize
69562
69563         bool
69564         isSrcOperand(int opIdx) override
69565         {
69566             switch (opIdx) {
69567               default:
69568                 fatal("op idx %i out of bounds\n", opIdx);
69569                 return false;
69570             }
69571         } // isSrcOperand
69572
69573         bool
69574         isDstOperand(int opIdx) override
69575         {
69576             switch (opIdx) {
69577               default:
69578                 fatal("op idx %i out of bounds\n", opIdx);
69579                 return false;
69580             }
69581         } // isDstOperand
69582
69583         void execute(GPUDynInstPtr) override;
69584         void initiateAcc(GPUDynInstPtr) override;
69585         void completeAcc(GPUDynInstPtr) override;
69586     }; // Inst_MUBUF__BUFFER_WBINVL1
69587
69588     class Inst_MUBUF__BUFFER_WBINVL1_VOL : public Inst_MUBUF
69589     {
69590       public:
69591         Inst_MUBUF__BUFFER_WBINVL1_VOL(InFmt_MUBUF*);
69592         ~Inst_MUBUF__BUFFER_WBINVL1_VOL();
69593
69594         int
69595         getNumOperands() override
69596         {
69597             return numDstRegOperands() + numSrcRegOperands();
69598         } // getNumOperands
69599
69600         int numDstRegOperands() override { return 0; }
69601         int numSrcRegOperands() override { return 0; }
69602
69603         int
69604         getOperandSize(int opIdx) override
69605         {
69606             switch (opIdx) {
69607               default:
69608                 fatal("op idx %i out of bounds\n", opIdx);
69609                 return -1;
69610             }
69611         } // getOperandSize
69612
69613         bool
69614         isSrcOperand(int opIdx) override
69615         {
69616             switch (opIdx) {
69617               default:
69618                 fatal("op idx %i out of bounds\n", opIdx);
69619                 return false;
69620             }
69621         } // isSrcOperand
69622
69623         bool
69624         isDstOperand(int opIdx) override
69625         {
69626             switch (opIdx) {
69627               default:
69628                 fatal("op idx %i out of bounds\n", opIdx);
69629                 return false;
69630             }
69631         } // isDstOperand
69632
69633         void execute(GPUDynInstPtr) override;
69634         void initiateAcc(GPUDynInstPtr) override;
69635         void completeAcc(GPUDynInstPtr) override;
69636     }; // Inst_MUBUF__BUFFER_WBINVL1_VOL
69637
69638     class Inst_MUBUF__BUFFER_ATOMIC_SWAP : public Inst_MUBUF
69639     {
69640       public:
69641         Inst_MUBUF__BUFFER_ATOMIC_SWAP(InFmt_MUBUF*);
69642         ~Inst_MUBUF__BUFFER_ATOMIC_SWAP();
69643
69644         int
69645         getNumOperands() override
69646         {
69647             return numDstRegOperands() + numSrcRegOperands();
69648         } // getNumOperands
69649
69650         int numDstRegOperands() override { return 1; }
69651         int numSrcRegOperands() override { return 3; }
69652
69653         int
69654         getOperandSize(int opIdx) override
69655         {
69656             switch (opIdx) {
69657               case 0: //vgpr_a
69658                 return 8;
69659               case 1: //sgpr_r
69660                 return 16;
69661               case 2: //sgpr_o
69662                 return 4;
69663               case 3: //vgpr_d
69664                 return 4;
69665               default:
69666                 fatal("op idx %i out of bounds\n", opIdx);
69667                 return -1;
69668             }
69669         } // getOperandSize
69670
69671         bool
69672         isSrcOperand(int opIdx) override
69673         {
69674             switch (opIdx) {
69675               case 0: //vgpr_a
69676                 return true;
69677               case 1: //sgpr_r
69678                 return true;
69679               case 2: //sgpr_o
69680                 return true;
69681               case 3: //vgpr_d
69682                 return false;
69683               default:
69684                 fatal("op idx %i out of bounds\n", opIdx);
69685                 return false;
69686             }
69687         } // isSrcOperand
69688
69689         bool
69690         isDstOperand(int opIdx) override
69691         {
69692             switch (opIdx) {
69693               case 0: //vgpr_a
69694                 return false;
69695               case 1: //sgpr_r
69696                 return false;
69697               case 2: //sgpr_o
69698                 return false;
69699               case 3: //vgpr_d
69700                 return true;
69701               default:
69702                 fatal("op idx %i out of bounds\n", opIdx);
69703                 return false;
69704             }
69705         } // isDstOperand
69706
69707         void execute(GPUDynInstPtr) override;
69708     }; // Inst_MUBUF__BUFFER_ATOMIC_SWAP
69709
69710     class Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP : public Inst_MUBUF
69711     {
69712       public:
69713         Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP(InFmt_MUBUF*);
69714         ~Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP();
69715
69716         int
69717         getNumOperands() override
69718         {
69719             return numDstRegOperands() + numSrcRegOperands();
69720         } // getNumOperands
69721
69722         int numDstRegOperands() override { return 1; }
69723         int numSrcRegOperands() override { return 3; }
69724
69725         int
69726         getOperandSize(int opIdx) override
69727         {
69728             switch (opIdx) {
69729               case 0: //vgpr_a
69730                 return 8;
69731               case 1: //sgpr_r
69732                 return 16;
69733               case 2: //sgpr_o
69734                 return 4;
69735               case 3: //vgpr_d
69736                 return 8;
69737               default:
69738                 fatal("op idx %i out of bounds\n", opIdx);
69739                 return -1;
69740             }
69741         } // getOperandSize
69742
69743         bool
69744         isSrcOperand(int opIdx) override
69745         {
69746             switch (opIdx) {
69747               case 0: //vgpr_a
69748                 return true;
69749               case 1: //sgpr_r
69750                 return true;
69751               case 2: //sgpr_o
69752                 return true;
69753               case 3: //vgpr_d
69754                 return false;
69755               default:
69756                 fatal("op idx %i out of bounds\n", opIdx);
69757                 return false;
69758             }
69759         } // isSrcOperand
69760
69761         bool
69762         isDstOperand(int opIdx) override
69763         {
69764             switch (opIdx) {
69765               case 0: //vgpr_a
69766                 return false;
69767               case 1: //sgpr_r
69768                 return false;
69769               case 2: //sgpr_o
69770                 return false;
69771               case 3: //vgpr_d
69772                 return true;
69773               default:
69774                 fatal("op idx %i out of bounds\n", opIdx);
69775                 return false;
69776             }
69777         } // isDstOperand
69778
69779         void execute(GPUDynInstPtr) override;
69780     }; // Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP
69781
69782     class Inst_MUBUF__BUFFER_ATOMIC_ADD : public Inst_MUBUF
69783     {
69784       public:
69785         Inst_MUBUF__BUFFER_ATOMIC_ADD(InFmt_MUBUF*);
69786         ~Inst_MUBUF__BUFFER_ATOMIC_ADD();
69787
69788         int
69789         getNumOperands() override
69790         {
69791             return numDstRegOperands() + numSrcRegOperands();
69792         } // getNumOperands
69793
69794         int numDstRegOperands() override { return 1; }
69795         int numSrcRegOperands() override { return 3; }
69796
69797         int
69798         getOperandSize(int opIdx) override
69799         {
69800             switch (opIdx) {
69801               case 0: //vgpr_a
69802                 return 8;
69803               case 1: //sgpr_r
69804                 return 16;
69805               case 2: //sgpr_o
69806                 return 4;
69807               case 3: //vgpr_d
69808                 return 4;
69809               default:
69810                 fatal("op idx %i out of bounds\n", opIdx);
69811                 return -1;
69812             }
69813         } // getOperandSize
69814
69815         bool
69816         isSrcOperand(int opIdx) override
69817         {
69818             switch (opIdx) {
69819               case 0: //vgpr_a
69820                 return true;
69821               case 1: //sgpr_r
69822                 return true;
69823               case 2: //sgpr_o
69824                 return true;
69825               case 3: //vgpr_d
69826                 return false;
69827               default:
69828                 fatal("op idx %i out of bounds\n", opIdx);
69829                 return false;
69830             }
69831         } // isSrcOperand
69832
69833         bool
69834         isDstOperand(int opIdx) override
69835         {
69836             switch (opIdx) {
69837               case 0: //vgpr_a
69838                 return false;
69839               case 1: //sgpr_r
69840                 return false;
69841               case 2: //sgpr_o
69842                 return false;
69843               case 3: //vgpr_d
69844                 return true;
69845               default:
69846                 fatal("op idx %i out of bounds\n", opIdx);
69847                 return false;
69848             }
69849         } // isDstOperand
69850
69851         void execute(GPUDynInstPtr) override;
69852     }; // Inst_MUBUF__BUFFER_ATOMIC_ADD
69853
69854     class Inst_MUBUF__BUFFER_ATOMIC_SUB : public Inst_MUBUF
69855     {
69856       public:
69857         Inst_MUBUF__BUFFER_ATOMIC_SUB(InFmt_MUBUF*);
69858         ~Inst_MUBUF__BUFFER_ATOMIC_SUB();
69859
69860         int
69861         getNumOperands() override
69862         {
69863             return numDstRegOperands() + numSrcRegOperands();
69864         } // getNumOperands
69865
69866         int numDstRegOperands() override { return 1; }
69867         int numSrcRegOperands() override { return 3; }
69868
69869         int
69870         getOperandSize(int opIdx) override
69871         {
69872             switch (opIdx) {
69873               case 0: //vgpr_a
69874                 return 8;
69875               case 1: //sgpr_r
69876                 return 16;
69877               case 2: //sgpr_o
69878                 return 4;
69879               case 3: //vgpr_d
69880                 return 4;
69881               default:
69882                 fatal("op idx %i out of bounds\n", opIdx);
69883                 return -1;
69884             }
69885         } // getOperandSize
69886
69887         bool
69888         isSrcOperand(int opIdx) override
69889         {
69890             switch (opIdx) {
69891               case 0: //vgpr_a
69892                 return true;
69893               case 1: //sgpr_r
69894                 return true;
69895               case 2: //sgpr_o
69896                 return true;
69897               case 3: //vgpr_d
69898                 return false;
69899               default:
69900                 fatal("op idx %i out of bounds\n", opIdx);
69901                 return false;
69902             }
69903         } // isSrcOperand
69904
69905         bool
69906         isDstOperand(int opIdx) override
69907         {
69908             switch (opIdx) {
69909               case 0: //vgpr_a
69910                 return false;
69911               case 1: //sgpr_r
69912                 return false;
69913               case 2: //sgpr_o
69914                 return false;
69915               case 3: //vgpr_d
69916                 return true;
69917               default:
69918                 fatal("op idx %i out of bounds\n", opIdx);
69919                 return false;
69920             }
69921         } // isDstOperand
69922
69923         void execute(GPUDynInstPtr) override;
69924     }; // Inst_MUBUF__BUFFER_ATOMIC_SUB
69925
69926     class Inst_MUBUF__BUFFER_ATOMIC_SMIN : public Inst_MUBUF
69927     {
69928       public:
69929         Inst_MUBUF__BUFFER_ATOMIC_SMIN(InFmt_MUBUF*);
69930         ~Inst_MUBUF__BUFFER_ATOMIC_SMIN();
69931
69932         int
69933         getNumOperands() override
69934         {
69935             return numDstRegOperands() + numSrcRegOperands();
69936         } // getNumOperands
69937
69938         int numDstRegOperands() override { return 1; }
69939         int numSrcRegOperands() override { return 3; }
69940
69941         int
69942         getOperandSize(int opIdx) override
69943         {
69944             switch (opIdx) {
69945               case 0: //vgpr_a
69946                 return 8;
69947               case 1: //sgpr_r
69948                 return 16;
69949               case 2: //sgpr_o
69950                 return 4;
69951               case 3: //vgpr_d
69952                 return 4;
69953               default:
69954                 fatal("op idx %i out of bounds\n", opIdx);
69955                 return -1;
69956             }
69957         } // getOperandSize
69958
69959         bool
69960         isSrcOperand(int opIdx) override
69961         {
69962             switch (opIdx) {
69963               case 0: //vgpr_a
69964                 return true;
69965               case 1: //sgpr_r
69966                 return true;
69967               case 2: //sgpr_o
69968                 return true;
69969               case 3: //vgpr_d
69970                 return false;
69971               default:
69972                 fatal("op idx %i out of bounds\n", opIdx);
69973                 return false;
69974             }
69975         } // isSrcOperand
69976
69977         bool
69978         isDstOperand(int opIdx) override
69979         {
69980             switch (opIdx) {
69981               case 0: //vgpr_a
69982                 return false;
69983               case 1: //sgpr_r
69984                 return false;
69985               case 2: //sgpr_o
69986                 return false;
69987               case 3: //vgpr_d
69988                 return true;
69989               default:
69990                 fatal("op idx %i out of bounds\n", opIdx);
69991                 return false;
69992             }
69993         } // isDstOperand
69994
69995         void execute(GPUDynInstPtr) override;
69996     }; // Inst_MUBUF__BUFFER_ATOMIC_SMIN
69997
69998     class Inst_MUBUF__BUFFER_ATOMIC_UMIN : public Inst_MUBUF
69999     {
70000       public:
70001         Inst_MUBUF__BUFFER_ATOMIC_UMIN(InFmt_MUBUF*);
70002         ~Inst_MUBUF__BUFFER_ATOMIC_UMIN();
70003
70004         int
70005         getNumOperands() override
70006         {
70007             return numDstRegOperands() + numSrcRegOperands();
70008         } // getNumOperands
70009
70010         int numDstRegOperands() override { return 1; }
70011         int numSrcRegOperands() override { return 3; }
70012
70013         int
70014         getOperandSize(int opIdx) override
70015         {
70016             switch (opIdx) {
70017               case 0: //vgpr_a
70018                 return 8;
70019               case 1: //sgpr_r
70020                 return 16;
70021               case 2: //sgpr_o
70022                 return 4;
70023               case 3: //vgpr_d
70024                 return 32;
70025               default:
70026                 fatal("op idx %i out of bounds\n", opIdx);
70027                 return -1;
70028             }
70029         } // getOperandSize
70030
70031         bool
70032         isSrcOperand(int opIdx) override
70033         {
70034             switch (opIdx) {
70035               case 0: //vgpr_a
70036                 return true;
70037               case 1: //sgpr_r
70038                 return true;
70039               case 2: //sgpr_o
70040                 return true;
70041               case 3: //vgpr_d
70042                 return false;
70043               default:
70044                 fatal("op idx %i out of bounds\n", opIdx);
70045                 return false;
70046             }
70047         } // isSrcOperand
70048
70049         bool
70050         isDstOperand(int opIdx) override
70051         {
70052             switch (opIdx) {
70053               case 0: //vgpr_a
70054                 return false;
70055               case 1: //sgpr_r
70056                 return false;
70057               case 2: //sgpr_o
70058                 return false;
70059               case 3: //vgpr_d
70060                 return true;
70061               default:
70062                 fatal("op idx %i out of bounds\n", opIdx);
70063                 return false;
70064             }
70065         } // isDstOperand
70066
70067         void execute(GPUDynInstPtr) override;
70068     }; // Inst_MUBUF__BUFFER_ATOMIC_UMIN
70069
70070     class Inst_MUBUF__BUFFER_ATOMIC_SMAX : public Inst_MUBUF
70071     {
70072       public:
70073         Inst_MUBUF__BUFFER_ATOMIC_SMAX(InFmt_MUBUF*);
70074         ~Inst_MUBUF__BUFFER_ATOMIC_SMAX();
70075
70076         int
70077         getNumOperands() override
70078         {
70079             return numDstRegOperands() + numSrcRegOperands();
70080         } // getNumOperands
70081
70082         int numDstRegOperands() override { return 1; }
70083         int numSrcRegOperands() override { return 3; }
70084
70085         int
70086         getOperandSize(int opIdx) override
70087         {
70088             switch (opIdx) {
70089               case 0: //vgpr_a
70090                 return 8;
70091               case 1: //sgpr_r
70092                 return 16;
70093               case 2: //sgpr_o
70094                 return 4;
70095               case 3: //vgpr_d
70096                 return 32;
70097               default:
70098                 fatal("op idx %i out of bounds\n", opIdx);
70099                 return -1;
70100             }
70101         } // getOperandSize
70102
70103         bool
70104         isSrcOperand(int opIdx) override
70105         {
70106             switch (opIdx) {
70107               case 0: //vgpr_a
70108                 return true;
70109               case 1: //sgpr_r
70110                 return true;
70111               case 2: //sgpr_o
70112                 return true;
70113               case 3: //vgpr_d
70114                 return false;
70115               default:
70116                 fatal("op idx %i out of bounds\n", opIdx);
70117                 return false;
70118             }
70119         } // isSrcOperand
70120
70121         bool
70122         isDstOperand(int opIdx) override
70123         {
70124             switch (opIdx) {
70125               case 0: //vgpr_a
70126                 return false;
70127               case 1: //sgpr_r
70128                 return false;
70129               case 2: //sgpr_o
70130                 return false;
70131               case 3: //vgpr_d
70132                 return true;
70133               default:
70134                 fatal("op idx %i out of bounds\n", opIdx);
70135                 return false;
70136             }
70137         } // isDstOperand
70138
70139         void execute(GPUDynInstPtr) override;
70140     }; // Inst_MUBUF__BUFFER_ATOMIC_SMAX
70141
70142     class Inst_MUBUF__BUFFER_ATOMIC_UMAX : public Inst_MUBUF
70143     {
70144       public:
70145         Inst_MUBUF__BUFFER_ATOMIC_UMAX(InFmt_MUBUF*);
70146         ~Inst_MUBUF__BUFFER_ATOMIC_UMAX();
70147
70148         int
70149         getNumOperands() override
70150         {
70151             return numDstRegOperands() + numSrcRegOperands();
70152         } // getNumOperands
70153
70154         int numDstRegOperands() override { return 1; }
70155         int numSrcRegOperands() override { return 3; }
70156
70157         int
70158         getOperandSize(int opIdx) override
70159         {
70160             switch (opIdx) {
70161               case 0: //vgpr_a
70162                 return 8;
70163               case 1: //sgpr_r
70164                 return 16;
70165               case 2: //sgpr_o
70166                 return 4;
70167               case 3: //vgpr_d
70168                 return 32;
70169               default:
70170                 fatal("op idx %i out of bounds\n", opIdx);
70171                 return -1;
70172             }
70173         } // getOperandSize
70174
70175         bool
70176         isSrcOperand(int opIdx) override
70177         {
70178             switch (opIdx) {
70179               case 0: //vgpr_a
70180                 return true;
70181               case 1: //sgpr_r
70182                 return true;
70183               case 2: //sgpr_o
70184                 return true;
70185               case 3: //vgpr_d
70186                 return false;
70187               default:
70188                 fatal("op idx %i out of bounds\n", opIdx);
70189                 return false;
70190             }
70191         } // isSrcOperand
70192
70193         bool
70194         isDstOperand(int opIdx) override
70195         {
70196             switch (opIdx) {
70197               case 0: //vgpr_a
70198                 return false;
70199               case 1: //sgpr_r
70200                 return false;
70201               case 2: //sgpr_o
70202                 return false;
70203               case 3: //vgpr_d
70204                 return true;
70205               default:
70206                 fatal("op idx %i out of bounds\n", opIdx);
70207                 return false;
70208             }
70209         } // isDstOperand
70210
70211         void execute(GPUDynInstPtr) override;
70212     }; // Inst_MUBUF__BUFFER_ATOMIC_UMAX
70213
70214     class Inst_MUBUF__BUFFER_ATOMIC_AND : public Inst_MUBUF
70215     {
70216       public:
70217         Inst_MUBUF__BUFFER_ATOMIC_AND(InFmt_MUBUF*);
70218         ~Inst_MUBUF__BUFFER_ATOMIC_AND();
70219
70220         int
70221         getNumOperands() override
70222         {
70223             return numDstRegOperands() + numSrcRegOperands();
70224         } // getNumOperands
70225
70226         int numDstRegOperands() override { return 1; }
70227         int numSrcRegOperands() override { return 3; }
70228
70229         int
70230         getOperandSize(int opIdx) override
70231         {
70232             switch (opIdx) {
70233               case 0: //vgpr_a
70234                 return 8;
70235               case 1: //sgpr_r
70236                 return 16;
70237               case 2: //sgpr_o
70238                 return 4;
70239               case 3: //vgpr_d
70240                 return 32;
70241               default:
70242                 fatal("op idx %i out of bounds\n", opIdx);
70243                 return -1;
70244             }
70245         } // getOperandSize
70246
70247         bool
70248         isSrcOperand(int opIdx) override
70249         {
70250             switch (opIdx) {
70251               case 0: //vgpr_a
70252                 return true;
70253               case 1: //sgpr_r
70254                 return true;
70255               case 2: //sgpr_o
70256                 return true;
70257               case 3: //vgpr_d
70258                 return false;
70259               default:
70260                 fatal("op idx %i out of bounds\n", opIdx);
70261                 return false;
70262             }
70263         } // isSrcOperand
70264
70265         bool
70266         isDstOperand(int opIdx) override
70267         {
70268             switch (opIdx) {
70269               case 0: //vgpr_a
70270                 return false;
70271               case 1: //sgpr_r
70272                 return false;
70273               case 2: //sgpr_o
70274                 return false;
70275               case 3: //vgpr_d
70276                 return true;
70277               default:
70278                 fatal("op idx %i out of bounds\n", opIdx);
70279                 return false;
70280             }
70281         } // isDstOperand
70282
70283         void execute(GPUDynInstPtr) override;
70284     }; // Inst_MUBUF__BUFFER_ATOMIC_AND
70285
70286     class Inst_MUBUF__BUFFER_ATOMIC_OR : public Inst_MUBUF
70287     {
70288       public:
70289         Inst_MUBUF__BUFFER_ATOMIC_OR(InFmt_MUBUF*);
70290         ~Inst_MUBUF__BUFFER_ATOMIC_OR();
70291
70292         int
70293         getNumOperands() override
70294         {
70295             return numDstRegOperands() + numSrcRegOperands();
70296         } // getNumOperands
70297
70298         int numDstRegOperands() override { return 1; }
70299         int numSrcRegOperands() override { return 3; }
70300
70301         int
70302         getOperandSize(int opIdx) override
70303         {
70304             switch (opIdx) {
70305               case 0: //vgpr_a
70306                 return 8;
70307               case 1: //sgpr_r
70308                 return 16;
70309               case 2: //sgpr_o
70310                 return 4;
70311               case 3: //vgpr_d
70312                 return 32;
70313               default:
70314                 fatal("op idx %i out of bounds\n", opIdx);
70315                 return -1;
70316             }
70317         } // getOperandSize
70318
70319         bool
70320         isSrcOperand(int opIdx) override
70321         {
70322             switch (opIdx) {
70323               case 0: //vgpr_a
70324                 return true;
70325               case 1: //sgpr_r
70326                 return true;
70327               case 2: //sgpr_o
70328                 return true;
70329               case 3: //vgpr_d
70330                 return false;
70331               default:
70332                 fatal("op idx %i out of bounds\n", opIdx);
70333                 return false;
70334             }
70335         } // isSrcOperand
70336
70337         bool
70338         isDstOperand(int opIdx) override
70339         {
70340             switch (opIdx) {
70341               case 0: //vgpr_a
70342                 return false;
70343               case 1: //sgpr_r
70344                 return false;
70345               case 2: //sgpr_o
70346                 return false;
70347               case 3: //vgpr_d
70348                 return true;
70349               default:
70350                 fatal("op idx %i out of bounds\n", opIdx);
70351                 return false;
70352             }
70353         } // isDstOperand
70354
70355         void execute(GPUDynInstPtr) override;
70356     }; // Inst_MUBUF__BUFFER_ATOMIC_OR
70357
70358     class Inst_MUBUF__BUFFER_ATOMIC_XOR : public Inst_MUBUF
70359     {
70360       public:
70361         Inst_MUBUF__BUFFER_ATOMIC_XOR(InFmt_MUBUF*);
70362         ~Inst_MUBUF__BUFFER_ATOMIC_XOR();
70363
70364         int
70365         getNumOperands() override
70366         {
70367             return numDstRegOperands() + numSrcRegOperands();
70368         } // getNumOperands
70369
70370         int numDstRegOperands() override { return 1; }
70371         int numSrcRegOperands() override { return 3; }
70372
70373         int
70374         getOperandSize(int opIdx) override
70375         {
70376             switch (opIdx) {
70377               case 0: //vgpr_a
70378                 return 8;
70379               case 1: //sgpr_r
70380                 return 16;
70381               case 2: //sgpr_o
70382                 return 4;
70383               case 3: //vgpr_d
70384                 return 32;
70385               default:
70386                 fatal("op idx %i out of bounds\n", opIdx);
70387                 return -1;
70388             }
70389         } // getOperandSize
70390
70391         bool
70392         isSrcOperand(int opIdx) override
70393         {
70394             switch (opIdx) {
70395               case 0: //vgpr_a
70396                 return true;
70397               case 1: //sgpr_r
70398                 return true;
70399               case 2: //sgpr_o
70400                 return true;
70401               case 3: //vgpr_d
70402                 return false;
70403               default:
70404                 fatal("op idx %i out of bounds\n", opIdx);
70405                 return false;
70406             }
70407         } // isSrcOperand
70408
70409         bool
70410         isDstOperand(int opIdx) override
70411         {
70412             switch (opIdx) {
70413               case 0: //vgpr_a
70414                 return false;
70415               case 1: //sgpr_r
70416                 return false;
70417               case 2: //sgpr_o
70418                 return false;
70419               case 3: //vgpr_d
70420                 return true;
70421               default:
70422                 fatal("op idx %i out of bounds\n", opIdx);
70423                 return false;
70424             }
70425         } // isDstOperand
70426
70427         void execute(GPUDynInstPtr) override;
70428     }; // Inst_MUBUF__BUFFER_ATOMIC_XOR
70429
70430     class Inst_MUBUF__BUFFER_ATOMIC_INC : public Inst_MUBUF
70431     {
70432       public:
70433         Inst_MUBUF__BUFFER_ATOMIC_INC(InFmt_MUBUF*);
70434         ~Inst_MUBUF__BUFFER_ATOMIC_INC();
70435
70436         int
70437         getNumOperands() override
70438         {
70439             return numDstRegOperands() + numSrcRegOperands();
70440         } // getNumOperands
70441
70442         int numDstRegOperands() override { return 1; }
70443         int numSrcRegOperands() override { return 3; }
70444
70445         int
70446         getOperandSize(int opIdx) override
70447         {
70448             switch (opIdx) {
70449               case 0: //vgpr_a
70450                 return 8;
70451               case 1: //sgpr_r
70452                 return 16;
70453               case 2: //sgpr_o
70454                 return 4;
70455               case 3: //vgpr_d
70456                 return 32;
70457               default:
70458                 fatal("op idx %i out of bounds\n", opIdx);
70459                 return -1;
70460             }
70461         } // getOperandSize
70462
70463         bool
70464         isSrcOperand(int opIdx) override
70465         {
70466             switch (opIdx) {
70467               case 0: //vgpr_a
70468                 return true;
70469               case 1: //sgpr_r
70470                 return true;
70471               case 2: //sgpr_o
70472                 return true;
70473               case 3: //vgpr_d
70474                 return false;
70475               default:
70476                 fatal("op idx %i out of bounds\n", opIdx);
70477                 return false;
70478             }
70479         } // isSrcOperand
70480
70481         bool
70482         isDstOperand(int opIdx) override
70483         {
70484             switch (opIdx) {
70485               case 0: //vgpr_a
70486                 return false;
70487               case 1: //sgpr_r
70488                 return false;
70489               case 2: //sgpr_o
70490                 return false;
70491               case 3: //vgpr_d
70492                 return true;
70493               default:
70494                 fatal("op idx %i out of bounds\n", opIdx);
70495                 return false;
70496             }
70497         } // isDstOperand
70498
70499         void execute(GPUDynInstPtr) override;
70500     }; // Inst_MUBUF__BUFFER_ATOMIC_INC
70501
70502     class Inst_MUBUF__BUFFER_ATOMIC_DEC : public Inst_MUBUF
70503     {
70504       public:
70505         Inst_MUBUF__BUFFER_ATOMIC_DEC(InFmt_MUBUF*);
70506         ~Inst_MUBUF__BUFFER_ATOMIC_DEC();
70507
70508         int
70509         getNumOperands() override
70510         {
70511             return numDstRegOperands() + numSrcRegOperands();
70512         } // getNumOperands
70513
70514         int numDstRegOperands() override { return 1; }
70515         int numSrcRegOperands() override { return 3; }
70516
70517         int
70518         getOperandSize(int opIdx) override
70519         {
70520             switch (opIdx) {
70521               case 0: //vgpr_a
70522                 return 8;
70523               case 1: //sgpr_r
70524                 return 16;
70525               case 2: //sgpr_o
70526                 return 4;
70527               case 3: //vgpr_d
70528                 return 32;
70529               default:
70530                 fatal("op idx %i out of bounds\n", opIdx);
70531                 return -1;
70532             }
70533         } // getOperandSize
70534
70535         bool
70536         isSrcOperand(int opIdx) override
70537         {
70538             switch (opIdx) {
70539               case 0: //vgpr_a
70540                 return true;
70541               case 1: //sgpr_r
70542                 return true;
70543               case 2: //sgpr_o
70544                 return true;
70545               case 3: //vgpr_d
70546                 return false;
70547               default:
70548                 fatal("op idx %i out of bounds\n", opIdx);
70549                 return false;
70550             }
70551         } // isSrcOperand
70552
70553         bool
70554         isDstOperand(int opIdx) override
70555         {
70556             switch (opIdx) {
70557               case 0: //vgpr_a
70558                 return false;
70559               case 1: //sgpr_r
70560                 return false;
70561               case 2: //sgpr_o
70562                 return false;
70563               case 3: //vgpr_d
70564                 return true;
70565               default:
70566                 fatal("op idx %i out of bounds\n", opIdx);
70567                 return false;
70568             }
70569         } // isDstOperand
70570
70571         void execute(GPUDynInstPtr) override;
70572     }; // Inst_MUBUF__BUFFER_ATOMIC_DEC
70573
70574     class Inst_MUBUF__BUFFER_ATOMIC_SWAP_X2 : public Inst_MUBUF
70575     {
70576       public:
70577         Inst_MUBUF__BUFFER_ATOMIC_SWAP_X2(InFmt_MUBUF*);
70578         ~Inst_MUBUF__BUFFER_ATOMIC_SWAP_X2();
70579
70580         int
70581         getNumOperands() override
70582         {
70583             return numDstRegOperands() + numSrcRegOperands();
70584         } // getNumOperands
70585
70586         int numDstRegOperands() override { return 1; }
70587         int numSrcRegOperands() override { return 3; }
70588
70589         int
70590         getOperandSize(int opIdx) override
70591         {
70592             switch (opIdx) {
70593               case 0: //vgpr_a
70594                 return 8;
70595               case 1: //sgpr_r
70596                 return 16;
70597               case 2: //sgpr_o
70598                 return 4;
70599               case 3: //vgpr_d
70600                 return 8;
70601               default:
70602                 fatal("op idx %i out of bounds\n", opIdx);
70603                 return -1;
70604             }
70605         } // getOperandSize
70606
70607         bool
70608         isSrcOperand(int opIdx) override
70609         {
70610             switch (opIdx) {
70611               case 0: //vgpr_a
70612                 return true;
70613               case 1: //sgpr_r
70614                 return true;
70615               case 2: //sgpr_o
70616                 return true;
70617               case 3: //vgpr_d
70618                 return false;
70619               default:
70620                 fatal("op idx %i out of bounds\n", opIdx);
70621                 return false;
70622             }
70623         } // isSrcOperand
70624
70625         bool
70626         isDstOperand(int opIdx) override
70627         {
70628             switch (opIdx) {
70629               case 0: //vgpr_a
70630                 return false;
70631               case 1: //sgpr_r
70632                 return false;
70633               case 2: //sgpr_o
70634                 return false;
70635               case 3: //vgpr_d
70636                 return true;
70637               default:
70638                 fatal("op idx %i out of bounds\n", opIdx);
70639                 return false;
70640             }
70641         } // isDstOperand
70642
70643         void execute(GPUDynInstPtr) override;
70644     }; // Inst_MUBUF__BUFFER_ATOMIC_SWAP_X2
70645
70646     class Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP_X2 : public Inst_MUBUF
70647     {
70648       public:
70649         Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP_X2(InFmt_MUBUF*);
70650         ~Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP_X2();
70651
70652         int
70653         getNumOperands() override
70654         {
70655             return numDstRegOperands() + numSrcRegOperands();
70656         } // getNumOperands
70657
70658         int numDstRegOperands() override { return 1; }
70659         int numSrcRegOperands() override { return 3; }
70660
70661         int
70662         getOperandSize(int opIdx) override
70663         {
70664             switch (opIdx) {
70665               case 0: //vgpr_a
70666                 return 8;
70667               case 1: //sgpr_r
70668                 return 16;
70669               case 2: //sgpr_o
70670                 return 4;
70671               case 3: //vgpr_d
70672                 return 16;
70673               default:
70674                 fatal("op idx %i out of bounds\n", opIdx);
70675                 return -1;
70676             }
70677         } // getOperandSize
70678
70679         bool
70680         isSrcOperand(int opIdx) override
70681         {
70682             switch (opIdx) {
70683               case 0: //vgpr_a
70684                 return true;
70685               case 1: //sgpr_r
70686                 return true;
70687               case 2: //sgpr_o
70688                 return true;
70689               case 3: //vgpr_d
70690                 return false;
70691               default:
70692                 fatal("op idx %i out of bounds\n", opIdx);
70693                 return false;
70694             }
70695         } // isSrcOperand
70696
70697         bool
70698         isDstOperand(int opIdx) override
70699         {
70700             switch (opIdx) {
70701               case 0: //vgpr_a
70702                 return false;
70703               case 1: //sgpr_r
70704                 return false;
70705               case 2: //sgpr_o
70706                 return false;
70707               case 3: //vgpr_d
70708                 return true;
70709               default:
70710                 fatal("op idx %i out of bounds\n", opIdx);
70711                 return false;
70712             }
70713         } // isDstOperand
70714
70715         void execute(GPUDynInstPtr) override;
70716     }; // Inst_MUBUF__BUFFER_ATOMIC_CMPSWAP_X2
70717
70718     class Inst_MUBUF__BUFFER_ATOMIC_ADD_X2 : public Inst_MUBUF
70719     {
70720       public:
70721         Inst_MUBUF__BUFFER_ATOMIC_ADD_X2(InFmt_MUBUF*);
70722         ~Inst_MUBUF__BUFFER_ATOMIC_ADD_X2();
70723
70724         int
70725         getNumOperands() override
70726         {
70727             return numDstRegOperands() + numSrcRegOperands();
70728         } // getNumOperands
70729
70730         int numDstRegOperands() override { return 1; }
70731         int numSrcRegOperands() override { return 3; }
70732
70733         int
70734         getOperandSize(int opIdx) override
70735         {
70736             switch (opIdx) {
70737               case 0: //vgpr_a
70738                 return 8;
70739               case 1: //sgpr_r
70740                 return 16;
70741               case 2: //sgpr_o
70742                 return 4;
70743               case 3: //vgpr_d
70744                 return 8;
70745               default:
70746                 fatal("op idx %i out of bounds\n", opIdx);
70747                 return -1;
70748             }
70749         } // getOperandSize
70750
70751         bool
70752         isSrcOperand(int opIdx) override
70753         {
70754             switch (opIdx) {
70755               case 0: //vgpr_a
70756                 return true;
70757               case 1: //sgpr_r
70758                 return true;
70759               case 2: //sgpr_o
70760                 return true;
70761               case 3: //vgpr_d
70762                 return false;
70763               default:
70764                 fatal("op idx %i out of bounds\n", opIdx);
70765                 return false;
70766             }
70767         } // isSrcOperand
70768
70769         bool
70770         isDstOperand(int opIdx) override
70771         {
70772             switch (opIdx) {
70773               case 0: //vgpr_a
70774                 return false;
70775               case 1: //sgpr_r
70776                 return false;
70777               case 2: //sgpr_o
70778                 return false;
70779               case 3: //vgpr_d
70780                 return true;
70781               default:
70782                 fatal("op idx %i out of bounds\n", opIdx);
70783                 return false;
70784             }
70785         } // isDstOperand
70786
70787         void execute(GPUDynInstPtr) override;
70788     }; // Inst_MUBUF__BUFFER_ATOMIC_ADD_X2
70789
70790     class Inst_MUBUF__BUFFER_ATOMIC_SUB_X2 : public Inst_MUBUF
70791     {
70792       public:
70793         Inst_MUBUF__BUFFER_ATOMIC_SUB_X2(InFmt_MUBUF*);
70794         ~Inst_MUBUF__BUFFER_ATOMIC_SUB_X2();
70795
70796         int
70797         getNumOperands() override
70798         {
70799             return numDstRegOperands() + numSrcRegOperands();
70800         } // getNumOperands
70801
70802         int numDstRegOperands() override { return 1; }
70803         int numSrcRegOperands() override { return 3; }
70804
70805         int
70806         getOperandSize(int opIdx) override
70807         {
70808             switch (opIdx) {
70809               case 0: //vgpr_a
70810                 return 8;
70811               case 1: //sgpr_r
70812                 return 16;
70813               case 2: //sgpr_o
70814                 return 4;
70815               case 3: //vgpr_d
70816                 return 8;
70817               default:
70818                 fatal("op idx %i out of bounds\n", opIdx);
70819                 return -1;
70820             }
70821         } // getOperandSize
70822
70823         bool
70824         isSrcOperand(int opIdx) override
70825         {
70826             switch (opIdx) {
70827               case 0: //vgpr_a
70828                 return true;
70829               case 1: //sgpr_r
70830                 return true;
70831               case 2: //sgpr_o
70832                 return true;
70833               case 3: //vgpr_d
70834                 return false;
70835               default:
70836                 fatal("op idx %i out of bounds\n", opIdx);
70837                 return false;
70838             }
70839         } // isSrcOperand
70840
70841         bool
70842         isDstOperand(int opIdx) override
70843         {
70844             switch (opIdx) {
70845               case 0: //vgpr_a
70846                 return false;
70847               case 1: //sgpr_r
70848                 return false;
70849               case 2: //sgpr_o
70850                 return false;
70851               case 3: //vgpr_d
70852                 return true;
70853               default:
70854                 fatal("op idx %i out of bounds\n", opIdx);
70855                 return false;
70856             }
70857         } // isDstOperand
70858
70859         void execute(GPUDynInstPtr) override;
70860     }; // Inst_MUBUF__BUFFER_ATOMIC_SUB_X2
70861
70862     class Inst_MUBUF__BUFFER_ATOMIC_SMIN_X2 : public Inst_MUBUF
70863     {
70864       public:
70865         Inst_MUBUF__BUFFER_ATOMIC_SMIN_X2(InFmt_MUBUF*);
70866         ~Inst_MUBUF__BUFFER_ATOMIC_SMIN_X2();
70867
70868         int
70869         getNumOperands() override
70870         {
70871             return numDstRegOperands() + numSrcRegOperands();
70872         } // getNumOperands
70873
70874         int numDstRegOperands() override { return 1; }
70875         int numSrcRegOperands() override { return 3; }
70876
70877         int
70878         getOperandSize(int opIdx) override
70879         {
70880             switch (opIdx) {
70881               case 0: //vgpr_a
70882                 return 8;
70883               case 1: //sgpr_r
70884                 return 16;
70885               case 2: //sgpr_o
70886                 return 4;
70887               case 3: //vgpr_d
70888                 return 8;
70889               default:
70890                 fatal("op idx %i out of bounds\n", opIdx);
70891                 return -1;
70892             }
70893         } // getOperandSize
70894
70895         bool
70896         isSrcOperand(int opIdx) override
70897         {
70898             switch (opIdx) {
70899               case 0: //vgpr_a
70900                 return true;
70901               case 1: //sgpr_r
70902                 return true;
70903               case 2: //sgpr_o
70904                 return true;
70905               case 3: //vgpr_d
70906                 return false;
70907               default:
70908                 fatal("op idx %i out of bounds\n", opIdx);
70909                 return false;
70910             }
70911         } // isSrcOperand
70912
70913         bool
70914         isDstOperand(int opIdx) override
70915         {
70916             switch (opIdx) {
70917               case 0: //vgpr_a
70918                 return false;
70919               case 1: //sgpr_r
70920                 return false;
70921               case 2: //sgpr_o
70922                 return false;
70923               case 3: //vgpr_d
70924                 return true;
70925               default:
70926                 fatal("op idx %i out of bounds\n", opIdx);
70927                 return false;
70928             }
70929         } // isDstOperand
70930
70931         void execute(GPUDynInstPtr) override;
70932     }; // Inst_MUBUF__BUFFER_ATOMIC_SMIN_X2
70933
70934     class Inst_MUBUF__BUFFER_ATOMIC_UMIN_X2 : public Inst_MUBUF
70935     {
70936       public:
70937         Inst_MUBUF__BUFFER_ATOMIC_UMIN_X2(InFmt_MUBUF*);
70938         ~Inst_MUBUF__BUFFER_ATOMIC_UMIN_X2();
70939
70940         int
70941         getNumOperands() override
70942         {
70943             return numDstRegOperands() + numSrcRegOperands();
70944         } // getNumOperands
70945
70946         int numDstRegOperands() override { return 1; }
70947         int numSrcRegOperands() override { return 3; }
70948
70949         int
70950         getOperandSize(int opIdx) override
70951         {
70952             switch (opIdx) {
70953               case 0: //vgpr_a
70954                 return 8;
70955               case 1: //sgpr_r
70956                 return 16;
70957               case 2: //sgpr_o
70958                 return 4;
70959               case 3: //vgpr_d
70960                 return 8;
70961               default:
70962                 fatal("op idx %i out of bounds\n", opIdx);
70963                 return -1;
70964             }
70965         } // getOperandSize
70966
70967         bool
70968         isSrcOperand(int opIdx) override
70969         {
70970             switch (opIdx) {
70971               case 0: //vgpr_a
70972                 return true;
70973               case 1: //sgpr_r
70974                 return true;
70975               case 2: //sgpr_o
70976                 return true;
70977               case 3: //vgpr_d
70978                 return false;
70979               default:
70980                 fatal("op idx %i out of bounds\n", opIdx);
70981                 return false;
70982             }
70983         } // isSrcOperand
70984
70985         bool
70986         isDstOperand(int opIdx) override
70987         {
70988             switch (opIdx) {
70989               case 0: //vgpr_a
70990                 return false;
70991               case 1: //sgpr_r
70992                 return false;
70993               case 2: //sgpr_o
70994                 return false;
70995               case 3: //vgpr_d
70996                 return true;
70997               default:
70998                 fatal("op idx %i out of bounds\n", opIdx);
70999                 return false;
71000             }
71001         } // isDstOperand
71002
71003         void execute(GPUDynInstPtr) override;
71004     }; // Inst_MUBUF__BUFFER_ATOMIC_UMIN_X2
71005
71006     class Inst_MUBUF__BUFFER_ATOMIC_SMAX_X2 : public Inst_MUBUF
71007     {
71008       public:
71009         Inst_MUBUF__BUFFER_ATOMIC_SMAX_X2(InFmt_MUBUF*);
71010         ~Inst_MUBUF__BUFFER_ATOMIC_SMAX_X2();
71011
71012         int
71013         getNumOperands() override
71014         {
71015             return numDstRegOperands() + numSrcRegOperands();
71016         } // getNumOperands
71017
71018         int numDstRegOperands() override { return 1; }
71019         int numSrcRegOperands() override { return 3; }
71020
71021         int
71022         getOperandSize(int opIdx) override
71023         {
71024             switch (opIdx) {
71025               case 0: //vgpr_a
71026                 return 8;
71027               case 1: //sgpr_r
71028                 return 16;
71029               case 2: //sgpr_o
71030                 return 4;
71031               case 3: //vgpr_d
71032                 return 8;
71033               default:
71034                 fatal("op idx %i out of bounds\n", opIdx);
71035                 return -1;
71036             }
71037         } // getOperandSize
71038
71039         bool
71040         isSrcOperand(int opIdx) override
71041         {
71042             switch (opIdx) {
71043               case 0: //vgpr_a
71044                 return true;
71045               case 1: //sgpr_r
71046                 return true;
71047               case 2: //sgpr_o
71048                 return true;
71049               case 3: //vgpr_d
71050                 return false;
71051               default:
71052                 fatal("op idx %i out of bounds\n", opIdx);
71053                 return false;
71054             }
71055         } // isSrcOperand
71056
71057         bool
71058         isDstOperand(int opIdx) override
71059         {
71060             switch (opIdx) {
71061               case 0: //vgpr_a
71062                 return false;
71063               case 1: //sgpr_r
71064                 return false;
71065               case 2: //sgpr_o
71066                 return false;
71067               case 3: //vgpr_d
71068                 return true;
71069               default:
71070                 fatal("op idx %i out of bounds\n", opIdx);
71071                 return false;
71072             }
71073         } // isDstOperand
71074
71075         void execute(GPUDynInstPtr) override;
71076     }; // Inst_MUBUF__BUFFER_ATOMIC_SMAX_X2
71077
71078     class Inst_MUBUF__BUFFER_ATOMIC_UMAX_X2 : public Inst_MUBUF
71079     {
71080       public:
71081         Inst_MUBUF__BUFFER_ATOMIC_UMAX_X2(InFmt_MUBUF*);
71082         ~Inst_MUBUF__BUFFER_ATOMIC_UMAX_X2();
71083
71084         int
71085         getNumOperands() override
71086         {
71087             return numDstRegOperands() + numSrcRegOperands();
71088         } // getNumOperands
71089
71090         int numDstRegOperands() override { return 1; }
71091         int numSrcRegOperands() override { return 3; }
71092
71093         int
71094         getOperandSize(int opIdx) override
71095         {
71096             switch (opIdx) {
71097               case 0: //vgpr_a
71098                 return 8;
71099               case 1: //sgpr_r
71100                 return 16;
71101               case 2: //sgpr_o
71102                 return 4;
71103               case 3: //vgpr_d
71104                 return 8;
71105               default:
71106                 fatal("op idx %i out of bounds\n", opIdx);
71107                 return -1;
71108             }
71109         } // getOperandSize
71110
71111         bool
71112         isSrcOperand(int opIdx) override
71113         {
71114             switch (opIdx) {
71115               case 0: //vgpr_a
71116                 return true;
71117               case 1: //sgpr_r
71118                 return true;
71119               case 2: //sgpr_o
71120                 return true;
71121               case 3: //vgpr_d
71122                 return false;
71123               default:
71124                 fatal("op idx %i out of bounds\n", opIdx);
71125                 return false;
71126             }
71127         } // isSrcOperand
71128
71129         bool
71130         isDstOperand(int opIdx) override
71131         {
71132             switch (opIdx) {
71133               case 0: //vgpr_a
71134                 return false;
71135               case 1: //sgpr_r
71136                 return false;
71137               case 2: //sgpr_o
71138                 return false;
71139               case 3: //vgpr_d
71140                 return true;
71141               default:
71142                 fatal("op idx %i out of bounds\n", opIdx);
71143                 return false;
71144             }
71145         } // isDstOperand
71146
71147         void execute(GPUDynInstPtr) override;
71148     }; // Inst_MUBUF__BUFFER_ATOMIC_UMAX_X2
71149
71150     class Inst_MUBUF__BUFFER_ATOMIC_AND_X2 : public Inst_MUBUF
71151     {
71152       public:
71153         Inst_MUBUF__BUFFER_ATOMIC_AND_X2(InFmt_MUBUF*);
71154         ~Inst_MUBUF__BUFFER_ATOMIC_AND_X2();
71155
71156         int
71157         getNumOperands() override
71158         {
71159             return numDstRegOperands() + numSrcRegOperands();
71160         } // getNumOperands
71161
71162         int numDstRegOperands() override { return 1; }
71163         int numSrcRegOperands() override { return 3; }
71164
71165         int
71166         getOperandSize(int opIdx) override
71167         {
71168             switch (opIdx) {
71169               case 0: //vgpr_a
71170                 return 8;
71171               case 1: //sgpr_r
71172                 return 16;
71173               case 2: //sgpr_o
71174                 return 4;
71175               case 3: //vgpr_d
71176                 return 8;
71177               default:
71178                 fatal("op idx %i out of bounds\n", opIdx);
71179                 return -1;
71180             }
71181         } // getOperandSize
71182
71183         bool
71184         isSrcOperand(int opIdx) override
71185         {
71186             switch (opIdx) {
71187               case 0: //vgpr_a
71188                 return true;
71189               case 1: //sgpr_r
71190                 return true;
71191               case 2: //sgpr_o
71192                 return true;
71193               case 3: //vgpr_d
71194                 return false;
71195               default:
71196                 fatal("op idx %i out of bounds\n", opIdx);
71197                 return false;
71198             }
71199         } // isSrcOperand
71200
71201         bool
71202         isDstOperand(int opIdx) override
71203         {
71204             switch (opIdx) {
71205               case 0: //vgpr_a
71206                 return false;
71207               case 1: //sgpr_r
71208                 return false;
71209               case 2: //sgpr_o
71210                 return false;
71211               case 3: //vgpr_d
71212                 return true;
71213               default:
71214                 fatal("op idx %i out of bounds\n", opIdx);
71215                 return false;
71216             }
71217         } // isDstOperand
71218
71219         void execute(GPUDynInstPtr) override;
71220     }; // Inst_MUBUF__BUFFER_ATOMIC_AND_X2
71221
71222     class Inst_MUBUF__BUFFER_ATOMIC_OR_X2 : public Inst_MUBUF
71223     {
71224       public:
71225         Inst_MUBUF__BUFFER_ATOMIC_OR_X2(InFmt_MUBUF*);
71226         ~Inst_MUBUF__BUFFER_ATOMIC_OR_X2();
71227
71228         int
71229         getNumOperands() override
71230         {
71231             return numDstRegOperands() + numSrcRegOperands();
71232         } // getNumOperands
71233
71234         int numDstRegOperands() override { return 1; }
71235         int numSrcRegOperands() override { return 3; }
71236
71237         int
71238         getOperandSize(int opIdx) override
71239         {
71240             switch (opIdx) {
71241               case 0: //vgpr_a
71242                 return 8;
71243               case 1: //sgpr_r
71244                 return 16;
71245               case 2: //sgpr_o
71246                 return 4;
71247               case 3: //vgpr_d
71248                 return 8;
71249               default:
71250                 fatal("op idx %i out of bounds\n", opIdx);
71251                 return -1;
71252             }
71253         } // getOperandSize
71254
71255         bool
71256         isSrcOperand(int opIdx) override
71257         {
71258             switch (opIdx) {
71259               case 0: //vgpr_a
71260                 return true;
71261               case 1: //sgpr_r
71262                 return true;
71263               case 2: //sgpr_o
71264                 return true;
71265               case 3: //vgpr_d
71266                 return false;
71267               default:
71268                 fatal("op idx %i out of bounds\n", opIdx);
71269                 return false;
71270             }
71271         } // isSrcOperand
71272
71273         bool
71274         isDstOperand(int opIdx) override
71275         {
71276             switch (opIdx) {
71277               case 0: //vgpr_a
71278                 return false;
71279               case 1: //sgpr_r
71280                 return false;
71281               case 2: //sgpr_o
71282                 return false;
71283               case 3: //vgpr_d
71284                 return true;
71285               default:
71286                 fatal("op idx %i out of bounds\n", opIdx);
71287                 return false;
71288             }
71289         } // isDstOperand
71290
71291         void execute(GPUDynInstPtr) override;
71292     }; // Inst_MUBUF__BUFFER_ATOMIC_OR_X2
71293
71294     class Inst_MUBUF__BUFFER_ATOMIC_XOR_X2 : public Inst_MUBUF
71295     {
71296       public:
71297         Inst_MUBUF__BUFFER_ATOMIC_XOR_X2(InFmt_MUBUF*);
71298         ~Inst_MUBUF__BUFFER_ATOMIC_XOR_X2();
71299
71300         int
71301         getNumOperands() override
71302         {
71303             return numDstRegOperands() + numSrcRegOperands();
71304         } // getNumOperands
71305
71306         int numDstRegOperands() override { return 1; }
71307         int numSrcRegOperands() override { return 3; }
71308
71309         int
71310         getOperandSize(int opIdx) override
71311         {
71312             switch (opIdx) {
71313               case 0: //vgpr_a
71314                 return 8;
71315               case 1: //sgpr_r
71316                 return 16;
71317               case 2: //sgpr_o
71318                 return 4;
71319               case 3: //vgpr_d
71320                 return 8;
71321               default:
71322                 fatal("op idx %i out of bounds\n", opIdx);
71323                 return -1;
71324             }
71325         } // getOperandSize
71326
71327         bool
71328         isSrcOperand(int opIdx) override
71329         {
71330             switch (opIdx) {
71331               case 0: //vgpr_a
71332                 return true;
71333               case 1: //sgpr_r
71334                 return true;
71335               case 2: //sgpr_o
71336                 return true;
71337               case 3: //vgpr_d
71338                 return false;
71339               default:
71340                 fatal("op idx %i out of bounds\n", opIdx);
71341                 return false;
71342             }
71343         } // isSrcOperand
71344
71345         bool
71346         isDstOperand(int opIdx) override
71347         {
71348             switch (opIdx) {
71349               case 0: //vgpr_a
71350                 return false;
71351               case 1: //sgpr_r
71352                 return false;
71353               case 2: //sgpr_o
71354                 return false;
71355               case 3: //vgpr_d
71356                 return true;
71357               default:
71358                 fatal("op idx %i out of bounds\n", opIdx);
71359                 return false;
71360             }
71361         } // isDstOperand
71362
71363         void execute(GPUDynInstPtr) override;
71364     }; // Inst_MUBUF__BUFFER_ATOMIC_XOR_X2
71365
71366     class Inst_MUBUF__BUFFER_ATOMIC_INC_X2 : public Inst_MUBUF
71367     {
71368       public:
71369         Inst_MUBUF__BUFFER_ATOMIC_INC_X2(InFmt_MUBUF*);
71370         ~Inst_MUBUF__BUFFER_ATOMIC_INC_X2();
71371
71372         int
71373         getNumOperands() override
71374         {
71375             return numDstRegOperands() + numSrcRegOperands();
71376         } // getNumOperands
71377
71378         int numDstRegOperands() override { return 1; }
71379         int numSrcRegOperands() override { return 3; }
71380
71381         int
71382         getOperandSize(int opIdx) override
71383         {
71384             switch (opIdx) {
71385               case 0: //vgpr_a
71386                 return 8;
71387               case 1: //sgpr_r
71388                 return 16;
71389               case 2: //sgpr_o
71390                 return 4;
71391               case 3: //vgpr_d
71392                 return 8;
71393               default:
71394                 fatal("op idx %i out of bounds\n", opIdx);
71395                 return -1;
71396             }
71397         } // getOperandSize
71398
71399         bool
71400         isSrcOperand(int opIdx) override
71401         {
71402             switch (opIdx) {
71403               case 0: //vgpr_a
71404                 return true;
71405               case 1: //sgpr_r
71406                 return true;
71407               case 2: //sgpr_o
71408                 return true;
71409               case 3: //vgpr_d
71410                 return false;
71411               default:
71412                 fatal("op idx %i out of bounds\n", opIdx);
71413                 return false;
71414             }
71415         } // isSrcOperand
71416
71417         bool
71418         isDstOperand(int opIdx) override
71419         {
71420             switch (opIdx) {
71421               case 0: //vgpr_a
71422                 return false;
71423               case 1: //sgpr_r
71424                 return false;
71425               case 2: //sgpr_o
71426                 return false;
71427               case 3: //vgpr_d
71428                 return true;
71429               default:
71430                 fatal("op idx %i out of bounds\n", opIdx);
71431                 return false;
71432             }
71433         } // isDstOperand
71434
71435         void execute(GPUDynInstPtr) override;
71436     }; // Inst_MUBUF__BUFFER_ATOMIC_INC_X2
71437
71438     class Inst_MUBUF__BUFFER_ATOMIC_DEC_X2 : public Inst_MUBUF
71439     {
71440       public:
71441         Inst_MUBUF__BUFFER_ATOMIC_DEC_X2(InFmt_MUBUF*);
71442         ~Inst_MUBUF__BUFFER_ATOMIC_DEC_X2();
71443
71444         int
71445         getNumOperands() override
71446         {
71447             return numDstRegOperands() + numSrcRegOperands();
71448         } // getNumOperands
71449
71450         int numDstRegOperands() override { return 1; }
71451         int numSrcRegOperands() override { return 3; }
71452
71453         int
71454         getOperandSize(int opIdx) override
71455         {
71456             switch (opIdx) {
71457               case 0: //vgpr_a
71458                 return 8;
71459               case 1: //sgpr_r
71460                 return 16;
71461               case 2: //sgpr_o
71462                 return 4;
71463               case 3: //vgpr_d
71464                 return 8;
71465               default:
71466                 fatal("op idx %i out of bounds\n", opIdx);
71467                 return -1;
71468             }
71469         } // getOperandSize
71470
71471         bool
71472         isSrcOperand(int opIdx) override
71473         {
71474             switch (opIdx) {
71475               case 0: //vgpr_a
71476                 return true;
71477               case 1: //sgpr_r
71478                 return true;
71479               case 2: //sgpr_o
71480                 return true;
71481               case 3: //vgpr_d
71482                 return false;
71483               default:
71484                 fatal("op idx %i out of bounds\n", opIdx);
71485                 return false;
71486             }
71487         } // isSrcOperand
71488
71489         bool
71490         isDstOperand(int opIdx) override
71491         {
71492             switch (opIdx) {
71493               case 0: //vgpr_a
71494                 return false;
71495               case 1: //sgpr_r
71496                 return false;
71497               case 2: //sgpr_o
71498                 return false;
71499               case 3: //vgpr_d
71500                 return true;
71501               default:
71502                 fatal("op idx %i out of bounds\n", opIdx);
71503                 return false;
71504             }
71505         } // isDstOperand
71506
71507         void execute(GPUDynInstPtr) override;
71508     }; // Inst_MUBUF__BUFFER_ATOMIC_DEC_X2
71509
71510     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_X : public Inst_MTBUF
71511     {
71512       public:
71513         Inst_MTBUF__TBUFFER_LOAD_FORMAT_X(InFmt_MTBUF*);
71514         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_X();
71515
71516         int
71517         getNumOperands() override
71518         {
71519             return numDstRegOperands() + numSrcRegOperands();
71520         } // getNumOperands
71521
71522         int numDstRegOperands() override { return 1; }
71523         int numSrcRegOperands() override { return 3; }
71524
71525         int
71526         getOperandSize(int opIdx) override
71527         {
71528             switch (opIdx) {
71529               case 0: //vgpr_a
71530                 return 8;
71531               case 1: //sgpr_r
71532                 return 4;
71533               case 2: //sgpr_o
71534                 return 4;
71535               case 3: //vgpr_d
71536                 return 32;
71537               default:
71538                 fatal("op idx %i out of bounds\n", opIdx);
71539                 return -1;
71540             }
71541         } // getOperandSize
71542
71543         bool
71544         isSrcOperand(int opIdx) override
71545         {
71546             switch (opIdx) {
71547               case 0: //vgpr_a
71548                 return true;
71549               case 1: //sgpr_r
71550                 return true;
71551               case 2: //sgpr_o
71552                 return true;
71553               case 3: //vgpr_d
71554                 return false;
71555               default:
71556                 fatal("op idx %i out of bounds\n", opIdx);
71557                 return false;
71558             }
71559         } // isSrcOperand
71560
71561         bool
71562         isDstOperand(int opIdx) override
71563         {
71564             switch (opIdx) {
71565               case 0: //vgpr_a
71566                 return false;
71567               case 1: //sgpr_r
71568                 return false;
71569               case 2: //sgpr_o
71570                 return false;
71571               case 3: //vgpr_d
71572                 return true;
71573               default:
71574                 fatal("op idx %i out of bounds\n", opIdx);
71575                 return false;
71576             }
71577         } // isDstOperand
71578
71579         void execute(GPUDynInstPtr) override;
71580         void initiateAcc(GPUDynInstPtr) override;
71581         void completeAcc(GPUDynInstPtr) override;
71582     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_X
71583
71584     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_XY : public Inst_MTBUF
71585     {
71586       public:
71587         Inst_MTBUF__TBUFFER_LOAD_FORMAT_XY(InFmt_MTBUF*);
71588         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_XY();
71589
71590         int
71591         getNumOperands() override
71592         {
71593             return numDstRegOperands() + numSrcRegOperands();
71594         } // getNumOperands
71595
71596         int numDstRegOperands() override { return 1; }
71597         int numSrcRegOperands() override { return 3; }
71598
71599         int
71600         getOperandSize(int opIdx) override
71601         {
71602             switch (opIdx) {
71603               case 0: //vgpr_a
71604                 return 8;
71605               case 1: //sgpr_r
71606                 return 4;
71607               case 2: //sgpr_o
71608                 return 4;
71609               case 3: //vgpr_d
71610                 return 8;
71611               default:
71612                 fatal("op idx %i out of bounds\n", opIdx);
71613                 return -1;
71614             }
71615         } // getOperandSize
71616
71617         bool
71618         isSrcOperand(int opIdx) override
71619         {
71620             switch (opIdx) {
71621               case 0: //vgpr_a
71622                 return true;
71623               case 1: //sgpr_r
71624                 return true;
71625               case 2: //sgpr_o
71626                 return true;
71627               case 3: //vgpr_d
71628                 return false;
71629               default:
71630                 fatal("op idx %i out of bounds\n", opIdx);
71631                 return false;
71632             }
71633         } // isSrcOperand
71634
71635         bool
71636         isDstOperand(int opIdx) override
71637         {
71638             switch (opIdx) {
71639               case 0: //vgpr_a
71640                 return false;
71641               case 1: //sgpr_r
71642                 return false;
71643               case 2: //sgpr_o
71644                 return false;
71645               case 3: //vgpr_d
71646                 return true;
71647               default:
71648                 fatal("op idx %i out of bounds\n", opIdx);
71649                 return false;
71650             }
71651         } // isDstOperand
71652
71653         void execute(GPUDynInstPtr) override;
71654         void initiateAcc(GPUDynInstPtr) override;
71655         void completeAcc(GPUDynInstPtr) override;
71656     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_XY
71657
71658     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZ : public Inst_MTBUF
71659     {
71660       public:
71661         Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZ(InFmt_MTBUF*);
71662         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZ();
71663
71664         int
71665         getNumOperands() override
71666         {
71667             return numDstRegOperands() + numSrcRegOperands();
71668         } // getNumOperands
71669
71670         int numDstRegOperands() override { return 1; }
71671         int numSrcRegOperands() override { return 3; }
71672
71673         int
71674         getOperandSize(int opIdx) override
71675         {
71676             switch (opIdx) {
71677               case 0: //vgpr_a
71678                 return 8;
71679               case 1: //sgpr_r
71680                 return 4;
71681               case 2: //sgpr_o
71682                 return 4;
71683               case 3: //vgpr_d
71684                 return 12;
71685               default:
71686                 fatal("op idx %i out of bounds\n", opIdx);
71687                 return -1;
71688             }
71689         } // getOperandSize
71690
71691         bool
71692         isSrcOperand(int opIdx) override
71693         {
71694             switch (opIdx) {
71695               case 0: //vgpr_a
71696                 return true;
71697               case 1: //sgpr_r
71698                 return true;
71699               case 2: //sgpr_o
71700                 return true;
71701               case 3: //vgpr_d
71702                 return false;
71703               default:
71704                 fatal("op idx %i out of bounds\n", opIdx);
71705                 return false;
71706             }
71707         } // isSrcOperand
71708
71709         bool
71710         isDstOperand(int opIdx) override
71711         {
71712             switch (opIdx) {
71713               case 0: //vgpr_a
71714                 return false;
71715               case 1: //sgpr_r
71716                 return false;
71717               case 2: //sgpr_o
71718                 return false;
71719               case 3: //vgpr_d
71720                 return true;
71721               default:
71722                 fatal("op idx %i out of bounds\n", opIdx);
71723                 return false;
71724             }
71725         } // isDstOperand
71726
71727         void execute(GPUDynInstPtr) override;
71728         void initiateAcc(GPUDynInstPtr) override;
71729         void completeAcc(GPUDynInstPtr) override;
71730     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZ
71731
71732     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZW : public Inst_MTBUF
71733     {
71734       public:
71735         Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZW(InFmt_MTBUF*);
71736         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZW();
71737
71738         int
71739         getNumOperands() override
71740         {
71741             return numDstRegOperands() + numSrcRegOperands();
71742         } // getNumOperands
71743
71744         int numDstRegOperands() override { return 1; }
71745         int numSrcRegOperands() override { return 3; }
71746
71747         int
71748         getOperandSize(int opIdx) override
71749         {
71750             switch (opIdx) {
71751               case 0: //vgpr_a
71752                 return 8;
71753               case 1: //sgpr_r
71754                 return 4;
71755               case 2: //sgpr_o
71756                 return 4;
71757               case 3: //vgpr_d
71758                 return 16;
71759               default:
71760                 fatal("op idx %i out of bounds\n", opIdx);
71761                 return -1;
71762             }
71763         } // getOperandSize
71764
71765         bool
71766         isSrcOperand(int opIdx) override
71767         {
71768             switch (opIdx) {
71769               case 0: //vgpr_a
71770                 return true;
71771               case 1: //sgpr_r
71772                 return true;
71773               case 2: //sgpr_o
71774                 return true;
71775               case 3: //vgpr_d
71776                 return false;
71777               default:
71778                 fatal("op idx %i out of bounds\n", opIdx);
71779                 return false;
71780             }
71781         } // isSrcOperand
71782
71783         bool
71784         isDstOperand(int opIdx) override
71785         {
71786             switch (opIdx) {
71787               case 0: //vgpr_a
71788                 return false;
71789               case 1: //sgpr_r
71790                 return false;
71791               case 2: //sgpr_o
71792                 return false;
71793               case 3: //vgpr_d
71794                 return true;
71795               default:
71796                 fatal("op idx %i out of bounds\n", opIdx);
71797                 return false;
71798             }
71799         } // isDstOperand
71800
71801         void execute(GPUDynInstPtr) override;
71802         void initiateAcc(GPUDynInstPtr) override;
71803         void completeAcc(GPUDynInstPtr) override;
71804     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_XYZW
71805
71806     class Inst_MTBUF__TBUFFER_STORE_FORMAT_X : public Inst_MTBUF
71807     {
71808       public:
71809         Inst_MTBUF__TBUFFER_STORE_FORMAT_X(InFmt_MTBUF*);
71810         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_X();
71811
71812         int
71813         getNumOperands() override
71814         {
71815             return numDstRegOperands() + numSrcRegOperands();
71816         } // getNumOperands
71817
71818         int numDstRegOperands() override { return 0; }
71819         int numSrcRegOperands() override { return 4; }
71820
71821         int
71822         getOperandSize(int opIdx) override
71823         {
71824             switch (opIdx) {
71825               case 0: //vgpr_d
71826                 return 32;
71827               case 1: //vgpr_a
71828                 return 8;
71829               case 2: //sgpr_r
71830                 return 4;
71831               case 3: //sgpr_o
71832                 return 4;
71833               default:
71834                 fatal("op idx %i out of bounds\n", opIdx);
71835                 return -1;
71836             }
71837         } // getOperandSize
71838
71839         bool
71840         isSrcOperand(int opIdx) override
71841         {
71842             switch (opIdx) {
71843               case 0: //vgpr_d
71844                 return true;
71845               case 1: //vgpr_a
71846                 return true;
71847               case 2: //sgpr_r
71848                 return true;
71849               case 3: //sgpr_o
71850                 return true;
71851               default:
71852                 fatal("op idx %i out of bounds\n", opIdx);
71853                 return false;
71854             }
71855         } // isSrcOperand
71856
71857         bool
71858         isDstOperand(int opIdx) override
71859         {
71860             switch (opIdx) {
71861               case 0: //vgpr_d
71862                 return false;
71863               case 1: //vgpr_a
71864                 return false;
71865               case 2: //sgpr_r
71866                 return false;
71867               case 3: //sgpr_o
71868                 return false;
71869               default:
71870                 fatal("op idx %i out of bounds\n", opIdx);
71871                 return false;
71872             }
71873         } // isDstOperand
71874
71875         void execute(GPUDynInstPtr) override;
71876         void initiateAcc(GPUDynInstPtr) override;
71877         void completeAcc(GPUDynInstPtr) override;
71878     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_X
71879
71880     class Inst_MTBUF__TBUFFER_STORE_FORMAT_XY : public Inst_MTBUF
71881     {
71882       public:
71883         Inst_MTBUF__TBUFFER_STORE_FORMAT_XY(InFmt_MTBUF*);
71884         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_XY();
71885
71886         int
71887         getNumOperands() override
71888         {
71889             return numDstRegOperands() + numSrcRegOperands();
71890         } // getNumOperands
71891
71892         int numDstRegOperands() override { return 0; }
71893         int numSrcRegOperands() override { return 4; }
71894
71895         int
71896         getOperandSize(int opIdx) override
71897         {
71898             switch (opIdx) {
71899               case 0: //vgpr_d
71900                 return 8;
71901               case 1: //vgpr_a
71902                 return 8;
71903               case 2: //sgpr_r
71904                 return 4;
71905               case 3: //sgpr_o
71906                 return 4;
71907               default:
71908                 fatal("op idx %i out of bounds\n", opIdx);
71909                 return -1;
71910             }
71911         } // getOperandSize
71912
71913         bool
71914         isSrcOperand(int opIdx) override
71915         {
71916             switch (opIdx) {
71917               case 0: //vgpr_d
71918                 return true;
71919               case 1: //vgpr_a
71920                 return true;
71921               case 2: //sgpr_r
71922                 return true;
71923               case 3: //sgpr_o
71924                 return true;
71925               default:
71926                 fatal("op idx %i out of bounds\n", opIdx);
71927                 return false;
71928             }
71929         } // isSrcOperand
71930
71931         bool
71932         isDstOperand(int opIdx) override
71933         {
71934             switch (opIdx) {
71935               case 0: //vgpr_d
71936                 return false;
71937               case 1: //vgpr_a
71938                 return false;
71939               case 2: //sgpr_r
71940                 return false;
71941               case 3: //sgpr_o
71942                 return false;
71943               default:
71944                 fatal("op idx %i out of bounds\n", opIdx);
71945                 return false;
71946             }
71947         } // isDstOperand
71948
71949         void execute(GPUDynInstPtr) override;
71950         void initiateAcc(GPUDynInstPtr) override;
71951         void completeAcc(GPUDynInstPtr) override;
71952     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_XY
71953
71954     class Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZ : public Inst_MTBUF
71955     {
71956       public:
71957         Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZ(InFmt_MTBUF*);
71958         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZ();
71959
71960         int
71961         getNumOperands() override
71962         {
71963             return numDstRegOperands() + numSrcRegOperands();
71964         } // getNumOperands
71965
71966         int numDstRegOperands() override { return 0; }
71967         int numSrcRegOperands() override { return 4; }
71968
71969         int
71970         getOperandSize(int opIdx) override
71971         {
71972             switch (opIdx) {
71973               case 0: //vgpr_d
71974                 return 12;
71975               case 1: //vgpr_a
71976                 return 8;
71977               case 2: //sgpr_r
71978                 return 4;
71979               case 3: //sgpr_o
71980                 return 4;
71981               default:
71982                 fatal("op idx %i out of bounds\n", opIdx);
71983                 return -1;
71984             }
71985         } // getOperandSize
71986
71987         bool
71988         isSrcOperand(int opIdx) override
71989         {
71990             switch (opIdx) {
71991               case 0: //vgpr_d
71992                 return true;
71993               case 1: //vgpr_a
71994                 return true;
71995               case 2: //sgpr_r
71996                 return true;
71997               case 3: //sgpr_o
71998                 return true;
71999               default:
72000                 fatal("op idx %i out of bounds\n", opIdx);
72001                 return false;
72002             }
72003         } // isSrcOperand
72004
72005         bool
72006         isDstOperand(int opIdx) override
72007         {
72008             switch (opIdx) {
72009               case 0: //vgpr_d
72010                 return false;
72011               case 1: //vgpr_a
72012                 return false;
72013               case 2: //sgpr_r
72014                 return false;
72015               case 3: //sgpr_o
72016                 return false;
72017               default:
72018                 fatal("op idx %i out of bounds\n", opIdx);
72019                 return false;
72020             }
72021         } // isDstOperand
72022
72023         void execute(GPUDynInstPtr) override;
72024         void initiateAcc(GPUDynInstPtr) override;
72025         void completeAcc(GPUDynInstPtr) override;
72026     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZ
72027
72028     class Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZW : public Inst_MTBUF
72029     {
72030       public:
72031         Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZW(InFmt_MTBUF*);
72032         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZW();
72033
72034         int
72035         getNumOperands() override
72036         {
72037             return numDstRegOperands() + numSrcRegOperands();
72038         } // getNumOperands
72039
72040         int numDstRegOperands() override { return 0; }
72041         int numSrcRegOperands() override { return 4; }
72042
72043         int
72044         getOperandSize(int opIdx) override
72045         {
72046             switch (opIdx) {
72047               case 0: //vgpr_d
72048                 return 16;
72049               case 1: //vgpr_a
72050                 return 8;
72051               case 2: //sgpr_r
72052                 return 4;
72053               case 3: //sgpr_o
72054                 return 4;
72055               default:
72056                 fatal("op idx %i out of bounds\n", opIdx);
72057                 return -1;
72058             }
72059         } // getOperandSize
72060
72061         bool
72062         isSrcOperand(int opIdx) override
72063         {
72064             switch (opIdx) {
72065               case 0: //vgpr_d
72066                 return true;
72067               case 1: //vgpr_a
72068                 return true;
72069               case 2: //sgpr_r
72070                 return true;
72071               case 3: //sgpr_o
72072                 return true;
72073               default:
72074                 fatal("op idx %i out of bounds\n", opIdx);
72075                 return false;
72076             }
72077         } // isSrcOperand
72078
72079         bool
72080         isDstOperand(int opIdx) override
72081         {
72082             switch (opIdx) {
72083               case 0: //vgpr_d
72084                 return false;
72085               case 1: //vgpr_a
72086                 return false;
72087               case 2: //sgpr_r
72088                 return false;
72089               case 3: //sgpr_o
72090                 return false;
72091               default:
72092                 fatal("op idx %i out of bounds\n", opIdx);
72093                 return false;
72094             }
72095         } // isDstOperand
72096
72097         void execute(GPUDynInstPtr) override;
72098         void initiateAcc(GPUDynInstPtr) override;
72099         void completeAcc(GPUDynInstPtr) override;
72100     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_XYZW
72101
72102     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_X : public Inst_MTBUF
72103     {
72104       public:
72105         Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_X(InFmt_MTBUF*);
72106         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_X();
72107
72108         int
72109         getNumOperands() override
72110         {
72111             return numDstRegOperands() + numSrcRegOperands();
72112         } // getNumOperands
72113
72114         int numDstRegOperands() override { return 1; }
72115         int numSrcRegOperands() override { return 3; }
72116
72117         int
72118         getOperandSize(int opIdx) override
72119         {
72120             switch (opIdx) {
72121               case 0: //vgpr_a
72122                 return 8;
72123               case 1: //sgpr_r
72124                 return 4;
72125               case 2: //sgpr_o
72126                 return 4;
72127               case 3: //vgpr_d
72128                 return 32;
72129               default:
72130                 fatal("op idx %i out of bounds\n", opIdx);
72131                 return -1;
72132             }
72133         } // getOperandSize
72134
72135         bool
72136         isSrcOperand(int opIdx) override
72137         {
72138             switch (opIdx) {
72139               case 0: //vgpr_a
72140                 return true;
72141               case 1: //sgpr_r
72142                 return true;
72143               case 2: //sgpr_o
72144                 return true;
72145               case 3: //vgpr_d
72146                 return false;
72147               default:
72148                 fatal("op idx %i out of bounds\n", opIdx);
72149                 return false;
72150             }
72151         } // isSrcOperand
72152
72153         bool
72154         isDstOperand(int opIdx) override
72155         {
72156             switch (opIdx) {
72157               case 0: //vgpr_a
72158                 return false;
72159               case 1: //sgpr_r
72160                 return false;
72161               case 2: //sgpr_o
72162                 return false;
72163               case 3: //vgpr_d
72164                 return true;
72165               default:
72166                 fatal("op idx %i out of bounds\n", opIdx);
72167                 return false;
72168             }
72169         } // isDstOperand
72170
72171         void execute(GPUDynInstPtr) override;
72172         void initiateAcc(GPUDynInstPtr) override;
72173         void completeAcc(GPUDynInstPtr) override;
72174     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_X
72175
72176     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XY : public Inst_MTBUF
72177     {
72178       public:
72179         Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XY(InFmt_MTBUF*);
72180         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XY();
72181
72182         int
72183         getNumOperands() override
72184         {
72185             return numDstRegOperands() + numSrcRegOperands();
72186         } // getNumOperands
72187
72188         int numDstRegOperands() override { return 1; }
72189         int numSrcRegOperands() override { return 3; }
72190
72191         int
72192         getOperandSize(int opIdx) override
72193         {
72194             switch (opIdx) {
72195               case 0: //vgpr_a
72196                 return 8;
72197               case 1: //sgpr_r
72198                 return 4;
72199               case 2: //sgpr_o
72200                 return 4;
72201               case 3: //vgpr_d
72202                 return 8;
72203               default:
72204                 fatal("op idx %i out of bounds\n", opIdx);
72205                 return -1;
72206             }
72207         } // getOperandSize
72208
72209         bool
72210         isSrcOperand(int opIdx) override
72211         {
72212             switch (opIdx) {
72213               case 0: //vgpr_a
72214                 return true;
72215               case 1: //sgpr_r
72216                 return true;
72217               case 2: //sgpr_o
72218                 return true;
72219               case 3: //vgpr_d
72220                 return false;
72221               default:
72222                 fatal("op idx %i out of bounds\n", opIdx);
72223                 return false;
72224             }
72225         } // isSrcOperand
72226
72227         bool
72228         isDstOperand(int opIdx) override
72229         {
72230             switch (opIdx) {
72231               case 0: //vgpr_a
72232                 return false;
72233               case 1: //sgpr_r
72234                 return false;
72235               case 2: //sgpr_o
72236                 return false;
72237               case 3: //vgpr_d
72238                 return true;
72239               default:
72240                 fatal("op idx %i out of bounds\n", opIdx);
72241                 return false;
72242             }
72243         } // isDstOperand
72244
72245         void execute(GPUDynInstPtr) override;
72246         void initiateAcc(GPUDynInstPtr) override;
72247         void completeAcc(GPUDynInstPtr) override;
72248     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XY
72249
72250     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZ : public Inst_MTBUF
72251     {
72252       public:
72253         Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZ(InFmt_MTBUF*);
72254         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZ();
72255
72256         int
72257         getNumOperands() override
72258         {
72259             return numDstRegOperands() + numSrcRegOperands();
72260         } // getNumOperands
72261
72262         int numDstRegOperands() override { return 1; }
72263         int numSrcRegOperands() override { return 3; }
72264
72265         int
72266         getOperandSize(int opIdx) override
72267         {
72268             switch (opIdx) {
72269               case 0: //vgpr_a
72270                 return 8;
72271               case 1: //sgpr_r
72272                 return 4;
72273               case 2: //sgpr_o
72274                 return 4;
72275               case 3: //vgpr_d
72276                 return 12;
72277               default:
72278                 fatal("op idx %i out of bounds\n", opIdx);
72279                 return -1;
72280             }
72281         } // getOperandSize
72282
72283         bool
72284         isSrcOperand(int opIdx) override
72285         {
72286             switch (opIdx) {
72287               case 0: //vgpr_a
72288                 return true;
72289               case 1: //sgpr_r
72290                 return true;
72291               case 2: //sgpr_o
72292                 return true;
72293               case 3: //vgpr_d
72294                 return false;
72295               default:
72296                 fatal("op idx %i out of bounds\n", opIdx);
72297                 return false;
72298             }
72299         } // isSrcOperand
72300
72301         bool
72302         isDstOperand(int opIdx) override
72303         {
72304             switch (opIdx) {
72305               case 0: //vgpr_a
72306                 return false;
72307               case 1: //sgpr_r
72308                 return false;
72309               case 2: //sgpr_o
72310                 return false;
72311               case 3: //vgpr_d
72312                 return true;
72313               default:
72314                 fatal("op idx %i out of bounds\n", opIdx);
72315                 return false;
72316             }
72317         } // isDstOperand
72318
72319         void execute(GPUDynInstPtr) override;
72320         void initiateAcc(GPUDynInstPtr) override;
72321         void completeAcc(GPUDynInstPtr) override;
72322     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZ
72323
72324     class Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZW : public Inst_MTBUF
72325     {
72326       public:
72327         Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZW(InFmt_MTBUF*);
72328         ~Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZW();
72329
72330         int
72331         getNumOperands() override
72332         {
72333             return numDstRegOperands() + numSrcRegOperands();
72334         } // getNumOperands
72335
72336         int numDstRegOperands() override { return 1; }
72337         int numSrcRegOperands() override { return 3; }
72338
72339         int
72340         getOperandSize(int opIdx) override
72341         {
72342             switch (opIdx) {
72343               case 0: //vgpr_a
72344                 return 8;
72345               case 1: //sgpr_r
72346                 return 4;
72347               case 2: //sgpr_o
72348                 return 4;
72349               case 3: //vgpr_d
72350                 return 16;
72351               default:
72352                 fatal("op idx %i out of bounds\n", opIdx);
72353                 return -1;
72354             }
72355         } // getOperandSize
72356
72357         bool
72358         isSrcOperand(int opIdx) override
72359         {
72360             switch (opIdx) {
72361               case 0: //vgpr_a
72362                 return true;
72363               case 1: //sgpr_r
72364                 return true;
72365               case 2: //sgpr_o
72366                 return true;
72367               case 3: //vgpr_d
72368                 return false;
72369               default:
72370                 fatal("op idx %i out of bounds\n", opIdx);
72371                 return false;
72372             }
72373         } // isSrcOperand
72374
72375         bool
72376         isDstOperand(int opIdx) override
72377         {
72378             switch (opIdx) {
72379               case 0: //vgpr_a
72380                 return false;
72381               case 1: //sgpr_r
72382                 return false;
72383               case 2: //sgpr_o
72384                 return false;
72385               case 3: //vgpr_d
72386                 return true;
72387               default:
72388                 fatal("op idx %i out of bounds\n", opIdx);
72389                 return false;
72390             }
72391         } // isDstOperand
72392
72393         void execute(GPUDynInstPtr) override;
72394         void initiateAcc(GPUDynInstPtr) override;
72395         void completeAcc(GPUDynInstPtr) override;
72396     }; // Inst_MTBUF__TBUFFER_LOAD_FORMAT_D16_XYZW
72397
72398     class Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_X : public Inst_MTBUF
72399     {
72400       public:
72401         Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_X(InFmt_MTBUF*);
72402         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_X();
72403
72404         int
72405         getNumOperands() override
72406         {
72407             return numDstRegOperands() + numSrcRegOperands();
72408         } // getNumOperands
72409
72410         int numDstRegOperands() override { return 0; }
72411         int numSrcRegOperands() override { return 4; }
72412
72413         int
72414         getOperandSize(int opIdx) override
72415         {
72416             switch (opIdx) {
72417               case 0: //vgpr_d
72418                 return 32;
72419               case 1: //vgpr_a
72420                 return 8;
72421               case 2: //sgpr_r
72422                 return 4;
72423               case 3: //sgpr_o
72424                 return 4;
72425               default:
72426                 fatal("op idx %i out of bounds\n", opIdx);
72427                 return -1;
72428             }
72429         } // getOperandSize
72430
72431         bool
72432         isSrcOperand(int opIdx) override
72433         {
72434             switch (opIdx) {
72435               case 0: //vgpr_d
72436                 return true;
72437               case 1: //vgpr_a
72438                 return true;
72439               case 2: //sgpr_r
72440                 return true;
72441               case 3: //sgpr_o
72442                 return true;
72443               default:
72444                 fatal("op idx %i out of bounds\n", opIdx);
72445                 return false;
72446             }
72447         } // isSrcOperand
72448
72449         bool
72450         isDstOperand(int opIdx) override
72451         {
72452             switch (opIdx) {
72453               case 0: //vgpr_d
72454                 return false;
72455               case 1: //vgpr_a
72456                 return false;
72457               case 2: //sgpr_r
72458                 return false;
72459               case 3: //sgpr_o
72460                 return false;
72461               default:
72462                 fatal("op idx %i out of bounds\n", opIdx);
72463                 return false;
72464             }
72465         } // isDstOperand
72466
72467         void execute(GPUDynInstPtr) override;
72468         void initiateAcc(GPUDynInstPtr) override;
72469         void completeAcc(GPUDynInstPtr) override;
72470     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_X
72471
72472     class Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XY : public Inst_MTBUF
72473     {
72474       public:
72475         Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XY(InFmt_MTBUF*);
72476         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XY();
72477
72478         int
72479         getNumOperands() override
72480         {
72481             return numDstRegOperands() + numSrcRegOperands();
72482         } // getNumOperands
72483
72484         int numDstRegOperands() override { return 0; }
72485         int numSrcRegOperands() override { return 4; }
72486
72487         int
72488         getOperandSize(int opIdx) override
72489         {
72490             switch (opIdx) {
72491               case 0: //vgpr_d
72492                 return 8;
72493               case 1: //vgpr_a
72494                 return 8;
72495               case 2: //sgpr_r
72496                 return 4;
72497               case 3: //sgpr_o
72498                 return 4;
72499               default:
72500                 fatal("op idx %i out of bounds\n", opIdx);
72501                 return -1;
72502             }
72503         } // getOperandSize
72504
72505         bool
72506         isSrcOperand(int opIdx) override
72507         {
72508             switch (opIdx) {
72509               case 0: //vgpr_d
72510                 return true;
72511               case 1: //vgpr_a
72512                 return true;
72513               case 2: //sgpr_r
72514                 return true;
72515               case 3: //sgpr_o
72516                 return true;
72517               default:
72518                 fatal("op idx %i out of bounds\n", opIdx);
72519                 return false;
72520             }
72521         } // isSrcOperand
72522
72523         bool
72524         isDstOperand(int opIdx) override
72525         {
72526             switch (opIdx) {
72527               case 0: //vgpr_d
72528                 return false;
72529               case 1: //vgpr_a
72530                 return false;
72531               case 2: //sgpr_r
72532                 return false;
72533               case 3: //sgpr_o
72534                 return false;
72535               default:
72536                 fatal("op idx %i out of bounds\n", opIdx);
72537                 return false;
72538             }
72539         } // isDstOperand
72540
72541         void execute(GPUDynInstPtr) override;
72542         void initiateAcc(GPUDynInstPtr) override;
72543         void completeAcc(GPUDynInstPtr) override;
72544     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XY
72545
72546     class Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZ : public Inst_MTBUF
72547     {
72548       public:
72549         Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZ(InFmt_MTBUF*);
72550         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZ();
72551
72552         int
72553         getNumOperands() override
72554         {
72555             return numDstRegOperands() + numSrcRegOperands();
72556         } // getNumOperands
72557
72558         int numDstRegOperands() override { return 0; }
72559         int numSrcRegOperands() override { return 4; }
72560
72561         int
72562         getOperandSize(int opIdx) override
72563         {
72564             switch (opIdx) {
72565               case 0: //vgpr_d
72566                 return 12;
72567               case 1: //vgpr_a
72568                 return 8;
72569               case 2: //sgpr_r
72570                 return 4;
72571               case 3: //sgpr_o
72572                 return 4;
72573               default:
72574                 fatal("op idx %i out of bounds\n", opIdx);
72575                 return -1;
72576             }
72577         } // getOperandSize
72578
72579         bool
72580         isSrcOperand(int opIdx) override
72581         {
72582             switch (opIdx) {
72583               case 0: //vgpr_d
72584                 return true;
72585               case 1: //vgpr_a
72586                 return true;
72587               case 2: //sgpr_r
72588                 return true;
72589               case 3: //sgpr_o
72590                 return true;
72591               default:
72592                 fatal("op idx %i out of bounds\n", opIdx);
72593                 return false;
72594             }
72595         } // isSrcOperand
72596
72597         bool
72598         isDstOperand(int opIdx) override
72599         {
72600             switch (opIdx) {
72601               case 0: //vgpr_d
72602                 return false;
72603               case 1: //vgpr_a
72604                 return false;
72605               case 2: //sgpr_r
72606                 return false;
72607               case 3: //sgpr_o
72608                 return false;
72609               default:
72610                 fatal("op idx %i out of bounds\n", opIdx);
72611                 return false;
72612             }
72613         } // isDstOperand
72614
72615         void execute(GPUDynInstPtr) override;
72616         void initiateAcc(GPUDynInstPtr) override;
72617         void completeAcc(GPUDynInstPtr) override;
72618     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZ
72619
72620     class Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZW : public Inst_MTBUF
72621     {
72622       public:
72623         Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZW(InFmt_MTBUF*);
72624         ~Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZW();
72625
72626         int
72627         getNumOperands() override
72628         {
72629             return numDstRegOperands() + numSrcRegOperands();
72630         } // getNumOperands
72631
72632         int numDstRegOperands() override { return 0; }
72633         int numSrcRegOperands() override { return 4; }
72634
72635         int
72636         getOperandSize(int opIdx) override
72637         {
72638             switch (opIdx) {
72639               case 0: //vgpr_d
72640                 return 16;
72641               case 1: //vgpr_a
72642                 return 8;
72643               case 2: //sgpr_r
72644                 return 4;
72645               case 3: //sgpr_o
72646                 return 4;
72647               default:
72648                 fatal("op idx %i out of bounds\n", opIdx);
72649                 return -1;
72650             }
72651         } // getOperandSize
72652
72653         bool
72654         isSrcOperand(int opIdx) override
72655         {
72656             switch (opIdx) {
72657               case 0: //vgpr_d
72658                 return true;
72659               case 1: //vgpr_a
72660                 return true;
72661               case 2: //sgpr_r
72662                 return true;
72663               case 3: //sgpr_o
72664                 return true;
72665               default:
72666                 fatal("op idx %i out of bounds\n", opIdx);
72667                 return false;
72668             }
72669         } // isSrcOperand
72670
72671         bool
72672         isDstOperand(int opIdx) override
72673         {
72674             switch (opIdx) {
72675               case 0: //vgpr_d
72676                 return false;
72677               case 1: //vgpr_a
72678                 return false;
72679               case 2: //sgpr_r
72680                 return false;
72681               case 3: //sgpr_o
72682                 return false;
72683               default:
72684                 fatal("op idx %i out of bounds\n", opIdx);
72685                 return false;
72686             }
72687         } // isDstOperand
72688
72689         void execute(GPUDynInstPtr) override;
72690         void initiateAcc(GPUDynInstPtr) override;
72691         void completeAcc(GPUDynInstPtr) override;
72692     }; // Inst_MTBUF__TBUFFER_STORE_FORMAT_D16_XYZW
72693
72694     class Inst_MIMG__IMAGE_LOAD : public Inst_MIMG
72695     {
72696       public:
72697         Inst_MIMG__IMAGE_LOAD(InFmt_MIMG*);
72698         ~Inst_MIMG__IMAGE_LOAD();
72699
72700         int
72701         getNumOperands() override
72702         {
72703             return numDstRegOperands() + numSrcRegOperands();
72704         } // getNumOperands
72705
72706         int numDstRegOperands() override { return 1; }
72707         int numSrcRegOperands() override { return 2; }
72708
72709         int
72710         getOperandSize(int opIdx) override
72711         {
72712             switch (opIdx) {
72713               case 0: //vgpr_a
72714                 return 16;
72715               case 1: //sgpr_r
72716                 return 32;
72717               case 2: //vgpr_d
72718                 return 16;
72719               default:
72720                 fatal("op idx %i out of bounds\n", opIdx);
72721                 return -1;
72722             }
72723         } // getOperandSize
72724
72725         bool
72726         isSrcOperand(int opIdx) override
72727         {
72728             switch (opIdx) {
72729               case 0: //vgpr_a
72730                 return true;
72731               case 1: //sgpr_r
72732                 return true;
72733               case 2: //vgpr_d
72734                 return false;
72735               default:
72736                 fatal("op idx %i out of bounds\n", opIdx);
72737                 return false;
72738             }
72739         } // isSrcOperand
72740
72741         bool
72742         isDstOperand(int opIdx) override
72743         {
72744             switch (opIdx) {
72745               case 0: //vgpr_a
72746                 return false;
72747               case 1: //sgpr_r
72748                 return false;
72749               case 2: //vgpr_d
72750                 return true;
72751               default:
72752                 fatal("op idx %i out of bounds\n", opIdx);
72753                 return false;
72754             }
72755         } // isDstOperand
72756
72757         void execute(GPUDynInstPtr) override;
72758         void initiateAcc(GPUDynInstPtr) override;
72759         void completeAcc(GPUDynInstPtr) override;
72760     }; // Inst_MIMG__IMAGE_LOAD
72761
72762     class Inst_MIMG__IMAGE_LOAD_MIP : public Inst_MIMG
72763     {
72764       public:
72765         Inst_MIMG__IMAGE_LOAD_MIP(InFmt_MIMG*);
72766         ~Inst_MIMG__IMAGE_LOAD_MIP();
72767
72768         int
72769         getNumOperands() override
72770         {
72771             return numDstRegOperands() + numSrcRegOperands();
72772         } // getNumOperands
72773
72774         int numDstRegOperands() override { return 1; }
72775         int numSrcRegOperands() override { return 2; }
72776
72777         int
72778         getOperandSize(int opIdx) override
72779         {
72780             switch (opIdx) {
72781               case 0: //vgpr_a
72782                 return 16;
72783               case 1: //sgpr_r
72784                 return 32;
72785               case 2: //vgpr_d
72786                 return 16;
72787               default:
72788                 fatal("op idx %i out of bounds\n", opIdx);
72789                 return -1;
72790             }
72791         } // getOperandSize
72792
72793         bool
72794         isSrcOperand(int opIdx) override
72795         {
72796             switch (opIdx) {
72797               case 0: //vgpr_a
72798                 return true;
72799               case 1: //sgpr_r
72800                 return true;
72801               case 2: //vgpr_d
72802                 return false;
72803               default:
72804                 fatal("op idx %i out of bounds\n", opIdx);
72805                 return false;
72806             }
72807         } // isSrcOperand
72808
72809         bool
72810         isDstOperand(int opIdx) override
72811         {
72812             switch (opIdx) {
72813               case 0: //vgpr_a
72814                 return false;
72815               case 1: //sgpr_r
72816                 return false;
72817               case 2: //vgpr_d
72818                 return true;
72819               default:
72820                 fatal("op idx %i out of bounds\n", opIdx);
72821                 return false;
72822             }
72823         } // isDstOperand
72824
72825         void execute(GPUDynInstPtr) override;
72826         void initiateAcc(GPUDynInstPtr) override;
72827         void completeAcc(GPUDynInstPtr) override;
72828     }; // Inst_MIMG__IMAGE_LOAD_MIP
72829
72830     class Inst_MIMG__IMAGE_LOAD_PCK : public Inst_MIMG
72831     {
72832       public:
72833         Inst_MIMG__IMAGE_LOAD_PCK(InFmt_MIMG*);
72834         ~Inst_MIMG__IMAGE_LOAD_PCK();
72835
72836         int
72837         getNumOperands() override
72838         {
72839             return numDstRegOperands() + numSrcRegOperands();
72840         } // getNumOperands
72841
72842         int numDstRegOperands() override { return 1; }
72843         int numSrcRegOperands() override { return 2; }
72844
72845         int
72846         getOperandSize(int opIdx) override
72847         {
72848             switch (opIdx) {
72849               case 0: //vgpr_a
72850                 return 16;
72851               case 1: //sgpr_r
72852                 return 32;
72853               case 2: //vgpr_d
72854                 return 16;
72855               default:
72856                 fatal("op idx %i out of bounds\n", opIdx);
72857                 return -1;
72858             }
72859         } // getOperandSize
72860
72861         bool
72862         isSrcOperand(int opIdx) override
72863         {
72864             switch (opIdx) {
72865               case 0: //vgpr_a
72866                 return true;
72867               case 1: //sgpr_r
72868                 return true;
72869               case 2: //vgpr_d
72870                 return false;
72871               default:
72872                 fatal("op idx %i out of bounds\n", opIdx);
72873                 return false;
72874             }
72875         } // isSrcOperand
72876
72877         bool
72878         isDstOperand(int opIdx) override
72879         {
72880             switch (opIdx) {
72881               case 0: //vgpr_a
72882                 return false;
72883               case 1: //sgpr_r
72884                 return false;
72885               case 2: //vgpr_d
72886                 return true;
72887               default:
72888                 fatal("op idx %i out of bounds\n", opIdx);
72889                 return false;
72890             }
72891         } // isDstOperand
72892
72893         void execute(GPUDynInstPtr) override;
72894         void initiateAcc(GPUDynInstPtr) override;
72895         void completeAcc(GPUDynInstPtr) override;
72896     }; // Inst_MIMG__IMAGE_LOAD_PCK
72897
72898     class Inst_MIMG__IMAGE_LOAD_PCK_SGN : public Inst_MIMG
72899     {
72900       public:
72901         Inst_MIMG__IMAGE_LOAD_PCK_SGN(InFmt_MIMG*);
72902         ~Inst_MIMG__IMAGE_LOAD_PCK_SGN();
72903
72904         int
72905         getNumOperands() override
72906         {
72907             return numDstRegOperands() + numSrcRegOperands();
72908         } // getNumOperands
72909
72910         int numDstRegOperands() override { return 1; }
72911         int numSrcRegOperands() override { return 2; }
72912
72913         int
72914         getOperandSize(int opIdx) override
72915         {
72916             switch (opIdx) {
72917               case 0: //vgpr_a
72918                 return 16;
72919               case 1: //sgpr_r
72920                 return 32;
72921               case 2: //vgpr_d
72922                 return 16;
72923               default:
72924                 fatal("op idx %i out of bounds\n", opIdx);
72925                 return -1;
72926             }
72927         } // getOperandSize
72928
72929         bool
72930         isSrcOperand(int opIdx) override
72931         {
72932             switch (opIdx) {
72933               case 0: //vgpr_a
72934                 return true;
72935               case 1: //sgpr_r
72936                 return true;
72937               case 2: //vgpr_d
72938                 return false;
72939               default:
72940                 fatal("op idx %i out of bounds\n", opIdx);
72941                 return false;
72942             }
72943         } // isSrcOperand
72944
72945         bool
72946         isDstOperand(int opIdx) override
72947         {
72948             switch (opIdx) {
72949               case 0: //vgpr_a
72950                 return false;
72951               case 1: //sgpr_r
72952                 return false;
72953               case 2: //vgpr_d
72954                 return true;
72955               default:
72956                 fatal("op idx %i out of bounds\n", opIdx);
72957                 return false;
72958             }
72959         } // isDstOperand
72960
72961         void execute(GPUDynInstPtr) override;
72962         void initiateAcc(GPUDynInstPtr) override;
72963         void completeAcc(GPUDynInstPtr) override;
72964     }; // Inst_MIMG__IMAGE_LOAD_PCK_SGN
72965
72966     class Inst_MIMG__IMAGE_LOAD_MIP_PCK : public Inst_MIMG
72967     {
72968       public:
72969         Inst_MIMG__IMAGE_LOAD_MIP_PCK(InFmt_MIMG*);
72970         ~Inst_MIMG__IMAGE_LOAD_MIP_PCK();
72971
72972         int
72973         getNumOperands() override
72974         {
72975             return numDstRegOperands() + numSrcRegOperands();
72976         } // getNumOperands
72977
72978         int numDstRegOperands() override { return 1; }
72979         int numSrcRegOperands() override { return 2; }
72980
72981         int
72982         getOperandSize(int opIdx) override
72983         {
72984             switch (opIdx) {
72985               case 0: //vgpr_a
72986                 return 16;
72987               case 1: //sgpr_r
72988                 return 32;
72989               case 2: //vgpr_d
72990                 return 16;
72991               default:
72992                 fatal("op idx %i out of bounds\n", opIdx);
72993                 return -1;
72994             }
72995         } // getOperandSize
72996
72997         bool
72998         isSrcOperand(int opIdx) override
72999         {
73000             switch (opIdx) {
73001               case 0: //vgpr_a
73002                 return true;
73003               case 1: //sgpr_r
73004                 return true;
73005               case 2: //vgpr_d
73006                 return false;
73007               default:
73008                 fatal("op idx %i out of bounds\n", opIdx);
73009                 return false;
73010             }
73011         } // isSrcOperand
73012
73013         bool
73014         isDstOperand(int opIdx) override
73015         {
73016             switch (opIdx) {
73017               case 0: //vgpr_a
73018                 return false;
73019               case 1: //sgpr_r
73020                 return false;
73021               case 2: //vgpr_d
73022                 return true;
73023               default:
73024                 fatal("op idx %i out of bounds\n", opIdx);
73025                 return false;
73026             }
73027         } // isDstOperand
73028
73029         void execute(GPUDynInstPtr) override;
73030         void initiateAcc(GPUDynInstPtr) override;
73031         void completeAcc(GPUDynInstPtr) override;
73032     }; // Inst_MIMG__IMAGE_LOAD_MIP_PCK
73033
73034     class Inst_MIMG__IMAGE_LOAD_MIP_PCK_SGN : public Inst_MIMG
73035     {
73036       public:
73037         Inst_MIMG__IMAGE_LOAD_MIP_PCK_SGN(InFmt_MIMG*);
73038         ~Inst_MIMG__IMAGE_LOAD_MIP_PCK_SGN();
73039
73040         int
73041         getNumOperands() override
73042         {
73043             return numDstRegOperands() + numSrcRegOperands();
73044         } // getNumOperands
73045
73046         int numDstRegOperands() override { return 1; }
73047         int numSrcRegOperands() override { return 2; }
73048
73049         int
73050         getOperandSize(int opIdx) override
73051         {
73052             switch (opIdx) {
73053               case 0: //vgpr_a
73054                 return 16;
73055               case 1: //sgpr_r
73056                 return 32;
73057               case 2: //vgpr_d
73058                 return 16;
73059               default:
73060                 fatal("op idx %i out of bounds\n", opIdx);
73061                 return -1;
73062             }
73063         } // getOperandSize
73064
73065         bool
73066         isSrcOperand(int opIdx) override
73067         {
73068             switch (opIdx) {
73069               case 0: //vgpr_a
73070                 return true;
73071               case 1: //sgpr_r
73072                 return true;
73073               case 2: //vgpr_d
73074                 return false;
73075               default:
73076                 fatal("op idx %i out of bounds\n", opIdx);
73077                 return false;
73078             }
73079         } // isSrcOperand
73080
73081         bool
73082         isDstOperand(int opIdx) override
73083         {
73084             switch (opIdx) {
73085               case 0: //vgpr_a
73086                 return false;
73087               case 1: //sgpr_r
73088                 return false;
73089               case 2: //vgpr_d
73090                 return true;
73091               default:
73092                 fatal("op idx %i out of bounds\n", opIdx);
73093                 return false;
73094             }
73095         } // isDstOperand
73096
73097         void execute(GPUDynInstPtr) override;
73098         void initiateAcc(GPUDynInstPtr) override;
73099         void completeAcc(GPUDynInstPtr) override;
73100     }; // Inst_MIMG__IMAGE_LOAD_MIP_PCK_SGN
73101
73102     class Inst_MIMG__IMAGE_STORE : public Inst_MIMG
73103     {
73104       public:
73105         Inst_MIMG__IMAGE_STORE(InFmt_MIMG*);
73106         ~Inst_MIMG__IMAGE_STORE();
73107
73108         int
73109         getNumOperands() override
73110         {
73111             return numDstRegOperands() + numSrcRegOperands();
73112         } // getNumOperands
73113
73114         int numDstRegOperands() override { return 0; }
73115         int numSrcRegOperands() override { return 3; }
73116
73117         int
73118         getOperandSize(int opIdx) override
73119         {
73120             switch (opIdx) {
73121               case 0: //vgpr_d
73122                 return 16;
73123               case 1: //vgpr_a
73124                 return 16;
73125               case 2: //sgpr_r
73126                 return 32;
73127               default:
73128                 fatal("op idx %i out of bounds\n", opIdx);
73129                 return -1;
73130             }
73131         } // getOperandSize
73132
73133         bool
73134         isSrcOperand(int opIdx) override
73135         {
73136             switch (opIdx) {
73137               case 0: //vgpr_d
73138                 return true;
73139               case 1: //vgpr_a
73140                 return true;
73141               case 2: //sgpr_r
73142                 return true;
73143               default:
73144                 fatal("op idx %i out of bounds\n", opIdx);
73145                 return false;
73146             }
73147         } // isSrcOperand
73148
73149         bool
73150         isDstOperand(int opIdx) override
73151         {
73152             switch (opIdx) {
73153               case 0: //vgpr_d
73154                 return false;
73155               case 1: //vgpr_a
73156                 return false;
73157               case 2: //sgpr_r
73158                 return false;
73159               default:
73160                 fatal("op idx %i out of bounds\n", opIdx);
73161                 return false;
73162             }
73163         } // isDstOperand
73164
73165         void execute(GPUDynInstPtr) override;
73166         void initiateAcc(GPUDynInstPtr) override;
73167         void completeAcc(GPUDynInstPtr) override;
73168     }; // Inst_MIMG__IMAGE_STORE
73169
73170     class Inst_MIMG__IMAGE_STORE_MIP : public Inst_MIMG
73171     {
73172       public:
73173         Inst_MIMG__IMAGE_STORE_MIP(InFmt_MIMG*);
73174         ~Inst_MIMG__IMAGE_STORE_MIP();
73175
73176         int
73177         getNumOperands() override
73178         {
73179             return numDstRegOperands() + numSrcRegOperands();
73180         } // getNumOperands
73181
73182         int numDstRegOperands() override { return 0; }
73183         int numSrcRegOperands() override { return 3; }
73184
73185         int
73186         getOperandSize(int opIdx) override
73187         {
73188             switch (opIdx) {
73189               case 0: //vgpr_d
73190                 return 16;
73191               case 1: //vgpr_a
73192                 return 16;
73193               case 2: //sgpr_r
73194                 return 32;
73195               default:
73196                 fatal("op idx %i out of bounds\n", opIdx);
73197                 return -1;
73198             }
73199         } // getOperandSize
73200
73201         bool
73202         isSrcOperand(int opIdx) override
73203         {
73204             switch (opIdx) {
73205               case 0: //vgpr_d
73206                 return true;
73207               case 1: //vgpr_a
73208                 return true;
73209               case 2: //sgpr_r
73210                 return true;
73211               default:
73212                 fatal("op idx %i out of bounds\n", opIdx);
73213                 return false;
73214             }
73215         } // isSrcOperand
73216
73217         bool
73218         isDstOperand(int opIdx) override
73219         {
73220             switch (opIdx) {
73221               case 0: //vgpr_d
73222                 return false;
73223               case 1: //vgpr_a
73224                 return false;
73225               case 2: //sgpr_r
73226                 return false;
73227               default:
73228                 fatal("op idx %i out of bounds\n", opIdx);
73229                 return false;
73230             }
73231         } // isDstOperand
73232
73233         void execute(GPUDynInstPtr) override;
73234         void initiateAcc(GPUDynInstPtr) override;
73235         void completeAcc(GPUDynInstPtr) override;
73236     }; // Inst_MIMG__IMAGE_STORE_MIP
73237
73238     class Inst_MIMG__IMAGE_STORE_PCK : public Inst_MIMG
73239     {
73240       public:
73241         Inst_MIMG__IMAGE_STORE_PCK(InFmt_MIMG*);
73242         ~Inst_MIMG__IMAGE_STORE_PCK();
73243
73244         int
73245         getNumOperands() override
73246         {
73247             return numDstRegOperands() + numSrcRegOperands();
73248         } // getNumOperands
73249
73250         int numDstRegOperands() override { return 0; }
73251         int numSrcRegOperands() override { return 3; }
73252
73253         int
73254         getOperandSize(int opIdx) override
73255         {
73256             switch (opIdx) {
73257               case 0: //vgpr_d
73258                 return 16;
73259               case 1: //vgpr_a
73260                 return 16;
73261               case 2: //sgpr_r
73262                 return 32;
73263               default:
73264                 fatal("op idx %i out of bounds\n", opIdx);
73265                 return -1;
73266             }
73267         } // getOperandSize
73268
73269         bool
73270         isSrcOperand(int opIdx) override
73271         {
73272             switch (opIdx) {
73273               case 0: //vgpr_d
73274                 return true;
73275               case 1: //vgpr_a
73276                 return true;
73277               case 2: //sgpr_r
73278                 return true;
73279               default:
73280                 fatal("op idx %i out of bounds\n", opIdx);
73281                 return false;
73282             }
73283         } // isSrcOperand
73284
73285         bool
73286         isDstOperand(int opIdx) override
73287         {
73288             switch (opIdx) {
73289               case 0: //vgpr_d
73290                 return false;
73291               case 1: //vgpr_a
73292                 return false;
73293               case 2: //sgpr_r
73294                 return false;
73295               default:
73296                 fatal("op idx %i out of bounds\n", opIdx);
73297                 return false;
73298             }
73299         } // isDstOperand
73300
73301         void execute(GPUDynInstPtr) override;
73302         void initiateAcc(GPUDynInstPtr) override;
73303         void completeAcc(GPUDynInstPtr) override;
73304     }; // Inst_MIMG__IMAGE_STORE_PCK
73305
73306     class Inst_MIMG__IMAGE_STORE_MIP_PCK : public Inst_MIMG
73307     {
73308       public:
73309         Inst_MIMG__IMAGE_STORE_MIP_PCK(InFmt_MIMG*);
73310         ~Inst_MIMG__IMAGE_STORE_MIP_PCK();
73311
73312         int
73313         getNumOperands() override
73314         {
73315             return numDstRegOperands() + numSrcRegOperands();
73316         } // getNumOperands
73317
73318         int numDstRegOperands() override { return 0; }
73319         int numSrcRegOperands() override { return 3; }
73320
73321         int
73322         getOperandSize(int opIdx) override
73323         {
73324             switch (opIdx) {
73325               case 0: //vgpr_d
73326                 return 16;
73327               case 1: //vgpr_a
73328                 return 16;
73329               case 2: //sgpr_r
73330                 return 32;
73331               default:
73332                 fatal("op idx %i out of bounds\n", opIdx);
73333                 return -1;
73334             }
73335         } // getOperandSize
73336
73337         bool
73338         isSrcOperand(int opIdx) override
73339         {
73340             switch (opIdx) {
73341               case 0: //vgpr_d
73342                 return true;
73343               case 1: //vgpr_a
73344                 return true;
73345               case 2: //sgpr_r
73346                 return true;
73347               default:
73348                 fatal("op idx %i out of bounds\n", opIdx);
73349                 return false;
73350             }
73351         } // isSrcOperand
73352
73353         bool
73354         isDstOperand(int opIdx) override
73355         {
73356             switch (opIdx) {
73357               case 0: //vgpr_d
73358                 return false;
73359               case 1: //vgpr_a
73360                 return false;
73361               case 2: //sgpr_r
73362                 return false;
73363               default:
73364                 fatal("op idx %i out of bounds\n", opIdx);
73365                 return false;
73366             }
73367         } // isDstOperand
73368
73369         void execute(GPUDynInstPtr) override;
73370         void initiateAcc(GPUDynInstPtr) override;
73371         void completeAcc(GPUDynInstPtr) override;
73372     }; // Inst_MIMG__IMAGE_STORE_MIP_PCK
73373
73374     class Inst_MIMG__IMAGE_GET_RESINFO : public Inst_MIMG
73375     {
73376       public:
73377         Inst_MIMG__IMAGE_GET_RESINFO(InFmt_MIMG*);
73378         ~Inst_MIMG__IMAGE_GET_RESINFO();
73379
73380         int
73381         getNumOperands() override
73382         {
73383             return numDstRegOperands() + numSrcRegOperands();
73384         } // getNumOperands
73385
73386         int numDstRegOperands() override { return 1; }
73387         int numSrcRegOperands() override { return 2; }
73388
73389         int
73390         getOperandSize(int opIdx) override
73391         {
73392             switch (opIdx) {
73393               case 0: //vgpr_a
73394                 return 16;
73395               case 1: //sgpr_r
73396                 return 32;
73397               case 2: //vgpr_d
73398                 return 16;
73399               default:
73400                 fatal("op idx %i out of bounds\n", opIdx);
73401                 return -1;
73402             }
73403         } // getOperandSize
73404
73405         bool
73406         isSrcOperand(int opIdx) override
73407         {
73408             switch (opIdx) {
73409               case 0: //vgpr_a
73410                 return true;
73411               case 1: //sgpr_r
73412                 return true;
73413               case 2: //vgpr_d
73414                 return false;
73415               default:
73416                 fatal("op idx %i out of bounds\n", opIdx);
73417                 return false;
73418             }
73419         } // isSrcOperand
73420
73421         bool
73422         isDstOperand(int opIdx) override
73423         {
73424             switch (opIdx) {
73425               case 0: //vgpr_a
73426                 return false;
73427               case 1: //sgpr_r
73428                 return false;
73429               case 2: //vgpr_d
73430                 return true;
73431               default:
73432                 fatal("op idx %i out of bounds\n", opIdx);
73433                 return false;
73434             }
73435         } // isDstOperand
73436
73437         void execute(GPUDynInstPtr) override;
73438     }; // Inst_MIMG__IMAGE_GET_RESINFO
73439
73440     class Inst_MIMG__IMAGE_ATOMIC_SWAP : public Inst_MIMG
73441     {
73442       public:
73443         Inst_MIMG__IMAGE_ATOMIC_SWAP(InFmt_MIMG*);
73444         ~Inst_MIMG__IMAGE_ATOMIC_SWAP();
73445
73446         int
73447         getNumOperands() override
73448         {
73449             return numDstRegOperands() + numSrcRegOperands();
73450         } // getNumOperands
73451
73452         int numDstRegOperands() override { return 1; }
73453         int numSrcRegOperands() override { return 2; }
73454
73455         int
73456         getOperandSize(int opIdx) override
73457         {
73458             switch (opIdx) {
73459               case 0: //vgpr_a
73460                 return 32;
73461               case 1: //sgpr_r
73462                 return 32;
73463               case 2: //vgpr_d
73464                 return 16;
73465               default:
73466                 fatal("op idx %i out of bounds\n", opIdx);
73467                 return -1;
73468             }
73469         } // getOperandSize
73470
73471         bool
73472         isSrcOperand(int opIdx) override
73473         {
73474             switch (opIdx) {
73475               case 0: //vgpr_a
73476                 return true;
73477               case 1: //sgpr_r
73478                 return true;
73479               case 2: //vgpr_d
73480                 return false;
73481               default:
73482                 fatal("op idx %i out of bounds\n", opIdx);
73483                 return false;
73484             }
73485         } // isSrcOperand
73486
73487         bool
73488         isDstOperand(int opIdx) override
73489         {
73490             switch (opIdx) {
73491               case 0: //vgpr_a
73492                 return false;
73493               case 1: //sgpr_r
73494                 return false;
73495               case 2: //vgpr_d
73496                 return true;
73497               default:
73498                 fatal("op idx %i out of bounds\n", opIdx);
73499                 return false;
73500             }
73501         } // isDstOperand
73502
73503         void execute(GPUDynInstPtr) override;
73504     }; // Inst_MIMG__IMAGE_ATOMIC_SWAP
73505
73506     class Inst_MIMG__IMAGE_ATOMIC_CMPSWAP : public Inst_MIMG
73507     {
73508       public:
73509         Inst_MIMG__IMAGE_ATOMIC_CMPSWAP(InFmt_MIMG*);
73510         ~Inst_MIMG__IMAGE_ATOMIC_CMPSWAP();
73511
73512         int
73513         getNumOperands() override
73514         {
73515             return numDstRegOperands() + numSrcRegOperands();
73516         } // getNumOperands
73517
73518         int numDstRegOperands() override { return 1; }
73519         int numSrcRegOperands() override { return 2; }
73520
73521         int
73522         getOperandSize(int opIdx) override
73523         {
73524             switch (opIdx) {
73525               case 0: //vgpr_a
73526                 return 32;
73527               case 1: //sgpr_r
73528                 return 32;
73529               case 2: //vgpr_d
73530                 return 16;
73531               default:
73532                 fatal("op idx %i out of bounds\n", opIdx);
73533                 return -1;
73534             }
73535         } // getOperandSize
73536
73537         bool
73538         isSrcOperand(int opIdx) override
73539         {
73540             switch (opIdx) {
73541               case 0: //vgpr_a
73542                 return true;
73543               case 1: //sgpr_r
73544                 return true;
73545               case 2: //vgpr_d
73546                 return false;
73547               default:
73548                 fatal("op idx %i out of bounds\n", opIdx);
73549                 return false;
73550             }
73551         } // isSrcOperand
73552
73553         bool
73554         isDstOperand(int opIdx) override
73555         {
73556             switch (opIdx) {
73557               case 0: //vgpr_a
73558                 return false;
73559               case 1: //sgpr_r
73560                 return false;
73561               case 2: //vgpr_d
73562                 return true;
73563               default:
73564                 fatal("op idx %i out of bounds\n", opIdx);
73565                 return false;
73566             }
73567         } // isDstOperand
73568
73569         void execute(GPUDynInstPtr) override;
73570     }; // Inst_MIMG__IMAGE_ATOMIC_CMPSWAP
73571
73572     class Inst_MIMG__IMAGE_ATOMIC_ADD : public Inst_MIMG
73573     {
73574       public:
73575         Inst_MIMG__IMAGE_ATOMIC_ADD(InFmt_MIMG*);
73576         ~Inst_MIMG__IMAGE_ATOMIC_ADD();
73577
73578         int
73579         getNumOperands() override
73580         {
73581             return numDstRegOperands() + numSrcRegOperands();
73582         } // getNumOperands
73583
73584         int numDstRegOperands() override { return 1; }
73585         int numSrcRegOperands() override { return 2; }
73586
73587         int
73588         getOperandSize(int opIdx) override
73589         {
73590             switch (opIdx) {
73591               case 0: //vgpr_a
73592                 return 32;
73593               case 1: //sgpr_r
73594                 return 32;
73595               case 2: //vgpr_d
73596                 return 16;
73597               default:
73598                 fatal("op idx %i out of bounds\n", opIdx);
73599                 return -1;
73600             }
73601         } // getOperandSize
73602
73603         bool
73604         isSrcOperand(int opIdx) override
73605         {
73606             switch (opIdx) {
73607               case 0: //vgpr_a
73608                 return true;
73609               case 1: //sgpr_r
73610                 return true;
73611               case 2: //vgpr_d
73612                 return false;
73613               default:
73614                 fatal("op idx %i out of bounds\n", opIdx);
73615                 return false;
73616             }
73617         } // isSrcOperand
73618
73619         bool
73620         isDstOperand(int opIdx) override
73621         {
73622             switch (opIdx) {
73623               case 0: //vgpr_a
73624                 return false;
73625               case 1: //sgpr_r
73626                 return false;
73627               case 2: //vgpr_d
73628                 return true;
73629               default:
73630                 fatal("op idx %i out of bounds\n", opIdx);
73631                 return false;
73632             }
73633         } // isDstOperand
73634
73635         void execute(GPUDynInstPtr) override;
73636     }; // Inst_MIMG__IMAGE_ATOMIC_ADD
73637
73638     class Inst_MIMG__IMAGE_ATOMIC_SUB : public Inst_MIMG
73639     {
73640       public:
73641         Inst_MIMG__IMAGE_ATOMIC_SUB(InFmt_MIMG*);
73642         ~Inst_MIMG__IMAGE_ATOMIC_SUB();
73643
73644         int
73645         getNumOperands() override
73646         {
73647             return numDstRegOperands() + numSrcRegOperands();
73648         } // getNumOperands
73649
73650         int numDstRegOperands() override { return 1; }
73651         int numSrcRegOperands() override { return 2; }
73652
73653         int
73654         getOperandSize(int opIdx) override
73655         {
73656             switch (opIdx) {
73657               case 0: //vgpr_a
73658                 return 32;
73659               case 1: //sgpr_r
73660                 return 32;
73661               case 2: //vgpr_d
73662                 return 16;
73663               default:
73664                 fatal("op idx %i out of bounds\n", opIdx);
73665                 return -1;
73666             }
73667         } // getOperandSize
73668
73669         bool
73670         isSrcOperand(int opIdx) override
73671         {
73672             switch (opIdx) {
73673               case 0: //vgpr_a
73674                 return true;
73675               case 1: //sgpr_r
73676                 return true;
73677               case 2: //vgpr_d
73678                 return false;
73679               default:
73680                 fatal("op idx %i out of bounds\n", opIdx);
73681                 return false;
73682             }
73683         } // isSrcOperand
73684
73685         bool
73686         isDstOperand(int opIdx) override
73687         {
73688             switch (opIdx) {
73689               case 0: //vgpr_a
73690                 return false;
73691               case 1: //sgpr_r
73692                 return false;
73693               case 2: //vgpr_d
73694                 return true;
73695               default:
73696                 fatal("op idx %i out of bounds\n", opIdx);
73697                 return false;
73698             }
73699         } // isDstOperand
73700
73701         void execute(GPUDynInstPtr) override;
73702     }; // Inst_MIMG__IMAGE_ATOMIC_SUB
73703
73704     class Inst_MIMG__IMAGE_ATOMIC_SMIN : public Inst_MIMG
73705     {
73706       public:
73707         Inst_MIMG__IMAGE_ATOMIC_SMIN(InFmt_MIMG*);
73708         ~Inst_MIMG__IMAGE_ATOMIC_SMIN();
73709
73710         int
73711         getNumOperands() override
73712         {
73713             return numDstRegOperands() + numSrcRegOperands();
73714         } // getNumOperands
73715
73716         int numDstRegOperands() override { return 1; }
73717         int numSrcRegOperands() override { return 2; }
73718
73719         int
73720         getOperandSize(int opIdx) override
73721         {
73722             switch (opIdx) {
73723               case 0: //vgpr_a
73724                 return 32;
73725               case 1: //sgpr_r
73726                 return 32;
73727               case 2: //vgpr_d
73728                 return 16;
73729               default:
73730                 fatal("op idx %i out of bounds\n", opIdx);
73731                 return -1;
73732             }
73733         } // getOperandSize
73734
73735         bool
73736         isSrcOperand(int opIdx) override
73737         {
73738             switch (opIdx) {
73739               case 0: //vgpr_a
73740                 return true;
73741               case 1: //sgpr_r
73742                 return true;
73743               case 2: //vgpr_d
73744                 return false;
73745               default:
73746                 fatal("op idx %i out of bounds\n", opIdx);
73747                 return false;
73748             }
73749         } // isSrcOperand
73750
73751         bool
73752         isDstOperand(int opIdx) override
73753         {
73754             switch (opIdx) {
73755               case 0: //vgpr_a
73756                 return false;
73757               case 1: //sgpr_r
73758                 return false;
73759               case 2: //vgpr_d
73760                 return true;
73761               default:
73762                 fatal("op idx %i out of bounds\n", opIdx);
73763                 return false;
73764             }
73765         } // isDstOperand
73766
73767         void execute(GPUDynInstPtr) override;
73768     }; // Inst_MIMG__IMAGE_ATOMIC_SMIN
73769
73770     class Inst_MIMG__IMAGE_ATOMIC_UMIN : public Inst_MIMG
73771     {
73772       public:
73773         Inst_MIMG__IMAGE_ATOMIC_UMIN(InFmt_MIMG*);
73774         ~Inst_MIMG__IMAGE_ATOMIC_UMIN();
73775
73776         int
73777         getNumOperands() override
73778         {
73779             return numDstRegOperands() + numSrcRegOperands();
73780         } // getNumOperands
73781
73782         int numDstRegOperands() override { return 1; }
73783         int numSrcRegOperands() override { return 2; }
73784
73785         int
73786         getOperandSize(int opIdx) override
73787         {
73788             switch (opIdx) {
73789               case 0: //vgpr_a
73790                 return 32;
73791               case 1: //sgpr_r
73792                 return 32;
73793               case 2: //vgpr_d
73794                 return 16;
73795               default:
73796                 fatal("op idx %i out of bounds\n", opIdx);
73797                 return -1;
73798             }
73799         } // getOperandSize
73800
73801         bool
73802         isSrcOperand(int opIdx) override
73803         {
73804             switch (opIdx) {
73805               case 0: //vgpr_a
73806                 return true;
73807               case 1: //sgpr_r
73808                 return true;
73809               case 2: //vgpr_d
73810                 return false;
73811               default:
73812                 fatal("op idx %i out of bounds\n", opIdx);
73813                 return false;
73814             }
73815         } // isSrcOperand
73816
73817         bool
73818         isDstOperand(int opIdx) override
73819         {
73820             switch (opIdx) {
73821               case 0: //vgpr_a
73822                 return false;
73823               case 1: //sgpr_r
73824                 return false;
73825               case 2: //vgpr_d
73826                 return true;
73827               default:
73828                 fatal("op idx %i out of bounds\n", opIdx);
73829                 return false;
73830             }
73831         } // isDstOperand
73832
73833         void execute(GPUDynInstPtr) override;
73834     }; // Inst_MIMG__IMAGE_ATOMIC_UMIN
73835
73836     class Inst_MIMG__IMAGE_ATOMIC_SMAX : public Inst_MIMG
73837     {
73838       public:
73839         Inst_MIMG__IMAGE_ATOMIC_SMAX(InFmt_MIMG*);
73840         ~Inst_MIMG__IMAGE_ATOMIC_SMAX();
73841
73842         int
73843         getNumOperands() override
73844         {
73845             return numDstRegOperands() + numSrcRegOperands();
73846         } // getNumOperands
73847
73848         int numDstRegOperands() override { return 1; }
73849         int numSrcRegOperands() override { return 2; }
73850
73851         int
73852         getOperandSize(int opIdx) override
73853         {
73854             switch (opIdx) {
73855               case 0: //vgpr_a
73856                 return 32;
73857               case 1: //sgpr_r
73858                 return 32;
73859               case 2: //vgpr_d
73860                 return 16;
73861               default:
73862                 fatal("op idx %i out of bounds\n", opIdx);
73863                 return -1;
73864             }
73865         } // getOperandSize
73866
73867         bool
73868         isSrcOperand(int opIdx) override
73869         {
73870             switch (opIdx) {
73871               case 0: //vgpr_a
73872                 return true;
73873               case 1: //sgpr_r
73874                 return true;
73875               case 2: //vgpr_d
73876                 return false;
73877               default:
73878                 fatal("op idx %i out of bounds\n", opIdx);
73879                 return false;
73880             }
73881         } // isSrcOperand
73882
73883         bool
73884         isDstOperand(int opIdx) override
73885         {
73886             switch (opIdx) {
73887               case 0: //vgpr_a
73888                 return false;
73889               case 1: //sgpr_r
73890                 return false;
73891               case 2: //vgpr_d
73892                 return true;
73893               default:
73894                 fatal("op idx %i out of bounds\n", opIdx);
73895                 return false;
73896             }
73897         } // isDstOperand
73898
73899         void execute(GPUDynInstPtr) override;
73900     }; // Inst_MIMG__IMAGE_ATOMIC_SMAX
73901
73902     class Inst_MIMG__IMAGE_ATOMIC_UMAX : public Inst_MIMG
73903     {
73904       public:
73905         Inst_MIMG__IMAGE_ATOMIC_UMAX(InFmt_MIMG*);
73906         ~Inst_MIMG__IMAGE_ATOMIC_UMAX();
73907
73908         int
73909         getNumOperands() override
73910         {
73911             return numDstRegOperands() + numSrcRegOperands();
73912         } // getNumOperands
73913
73914         int numDstRegOperands() override { return 1; }
73915         int numSrcRegOperands() override { return 2; }
73916
73917         int
73918         getOperandSize(int opIdx) override
73919         {
73920             switch (opIdx) {
73921               case 0: //vgpr_a
73922                 return 32;
73923               case 1: //sgpr_r
73924                 return 32;
73925               case 2: //vgpr_d
73926                 return 16;
73927               default:
73928                 fatal("op idx %i out of bounds\n", opIdx);
73929                 return -1;
73930             }
73931         } // getOperandSize
73932
73933         bool
73934         isSrcOperand(int opIdx) override
73935         {
73936             switch (opIdx) {
73937               case 0: //vgpr_a
73938                 return true;
73939               case 1: //sgpr_r
73940                 return true;
73941               case 2: //vgpr_d
73942                 return false;
73943               default:
73944                 fatal("op idx %i out of bounds\n", opIdx);
73945                 return false;
73946             }
73947         } // isSrcOperand
73948
73949         bool
73950         isDstOperand(int opIdx) override
73951         {
73952             switch (opIdx) {
73953               case 0: //vgpr_a
73954                 return false;
73955               case 1: //sgpr_r
73956                 return false;
73957               case 2: //vgpr_d
73958                 return true;
73959               default:
73960                 fatal("op idx %i out of bounds\n", opIdx);
73961                 return false;
73962             }
73963         } // isDstOperand
73964
73965         void execute(GPUDynInstPtr) override;
73966     }; // Inst_MIMG__IMAGE_ATOMIC_UMAX
73967
73968     class Inst_MIMG__IMAGE_ATOMIC_AND : public Inst_MIMG
73969     {
73970       public:
73971         Inst_MIMG__IMAGE_ATOMIC_AND(InFmt_MIMG*);
73972         ~Inst_MIMG__IMAGE_ATOMIC_AND();
73973
73974         int
73975         getNumOperands() override
73976         {
73977             return numDstRegOperands() + numSrcRegOperands();
73978         } // getNumOperands
73979
73980         int numDstRegOperands() override { return 1; }
73981         int numSrcRegOperands() override { return 2; }
73982
73983         int
73984         getOperandSize(int opIdx) override
73985         {
73986             switch (opIdx) {
73987               case 0: //vgpr_a
73988                 return 32;
73989               case 1: //sgpr_r
73990                 return 32;
73991               case 2: //vgpr_d
73992                 return 16;
73993               default:
73994                 fatal("op idx %i out of bounds\n", opIdx);
73995                 return -1;
73996             }
73997         } // getOperandSize
73998
73999         bool
74000         isSrcOperand(int opIdx) override
74001         {
74002             switch (opIdx) {
74003               case 0: //vgpr_a
74004                 return true;
74005               case 1: //sgpr_r
74006                 return true;
74007               case 2: //vgpr_d
74008                 return false;
74009               default:
74010                 fatal("op idx %i out of bounds\n", opIdx);
74011                 return false;
74012             }
74013         } // isSrcOperand
74014
74015         bool
74016         isDstOperand(int opIdx) override
74017         {
74018             switch (opIdx) {
74019               case 0: //vgpr_a
74020                 return false;
74021               case 1: //sgpr_r
74022                 return false;
74023               case 2: //vgpr_d
74024                 return true;
74025               default:
74026                 fatal("op idx %i out of bounds\n", opIdx);
74027                 return false;
74028             }
74029         } // isDstOperand
74030
74031         void execute(GPUDynInstPtr) override;
74032     }; // Inst_MIMG__IMAGE_ATOMIC_AND
74033
74034     class Inst_MIMG__IMAGE_ATOMIC_OR : public Inst_MIMG
74035     {
74036       public:
74037         Inst_MIMG__IMAGE_ATOMIC_OR(InFmt_MIMG*);
74038         ~Inst_MIMG__IMAGE_ATOMIC_OR();
74039
74040         int
74041         getNumOperands() override
74042         {
74043             return numDstRegOperands() + numSrcRegOperands();
74044         } // getNumOperands
74045
74046         int numDstRegOperands() override { return 1; }
74047         int numSrcRegOperands() override { return 2; }
74048
74049         int
74050         getOperandSize(int opIdx) override
74051         {
74052             switch (opIdx) {
74053               case 0: //vgpr_a
74054                 return 32;
74055               case 1: //sgpr_r
74056                 return 32;
74057               case 2: //vgpr_d
74058                 return 16;
74059               default:
74060                 fatal("op idx %i out of bounds\n", opIdx);
74061                 return -1;
74062             }
74063         } // getOperandSize
74064
74065         bool
74066         isSrcOperand(int opIdx) override
74067         {
74068             switch (opIdx) {
74069               case 0: //vgpr_a
74070                 return true;
74071               case 1: //sgpr_r
74072                 return true;
74073               case 2: //vgpr_d
74074                 return false;
74075               default:
74076                 fatal("op idx %i out of bounds\n", opIdx);
74077                 return false;
74078             }
74079         } // isSrcOperand
74080
74081         bool
74082         isDstOperand(int opIdx) override
74083         {
74084             switch (opIdx) {
74085               case 0: //vgpr_a
74086                 return false;
74087               case 1: //sgpr_r
74088                 return false;
74089               case 2: //vgpr_d
74090                 return true;
74091               default:
74092                 fatal("op idx %i out of bounds\n", opIdx);
74093                 return false;
74094             }
74095         } // isDstOperand
74096
74097         void execute(GPUDynInstPtr) override;
74098     }; // Inst_MIMG__IMAGE_ATOMIC_OR
74099
74100     class Inst_MIMG__IMAGE_ATOMIC_XOR : public Inst_MIMG
74101     {
74102       public:
74103         Inst_MIMG__IMAGE_ATOMIC_XOR(InFmt_MIMG*);
74104         ~Inst_MIMG__IMAGE_ATOMIC_XOR();
74105
74106         int
74107         getNumOperands() override
74108         {
74109             return numDstRegOperands() + numSrcRegOperands();
74110         } // getNumOperands
74111
74112         int numDstRegOperands() override { return 1; }
74113         int numSrcRegOperands() override { return 2; }
74114
74115         int
74116         getOperandSize(int opIdx) override
74117         {
74118             switch (opIdx) {
74119               case 0: //vgpr_a
74120                 return 32;
74121               case 1: //sgpr_r
74122                 return 32;
74123               case 2: //vgpr_d
74124                 return 16;
74125               default:
74126                 fatal("op idx %i out of bounds\n", opIdx);
74127                 return -1;
74128             }
74129         } // getOperandSize
74130
74131         bool
74132         isSrcOperand(int opIdx) override
74133         {
74134             switch (opIdx) {
74135               case 0: //vgpr_a
74136                 return true;
74137               case 1: //sgpr_r
74138                 return true;
74139               case 2: //vgpr_d
74140                 return false;
74141               default:
74142                 fatal("op idx %i out of bounds\n", opIdx);
74143                 return false;
74144             }
74145         } // isSrcOperand
74146
74147         bool
74148         isDstOperand(int opIdx) override
74149         {
74150             switch (opIdx) {
74151               case 0: //vgpr_a
74152                 return false;
74153               case 1: //sgpr_r
74154                 return false;
74155               case 2: //vgpr_d
74156                 return true;
74157               default:
74158                 fatal("op idx %i out of bounds\n", opIdx);
74159                 return false;
74160             }
74161         } // isDstOperand
74162
74163         void execute(GPUDynInstPtr) override;
74164     }; // Inst_MIMG__IMAGE_ATOMIC_XOR
74165
74166     class Inst_MIMG__IMAGE_ATOMIC_INC : public Inst_MIMG
74167     {
74168       public:
74169         Inst_MIMG__IMAGE_ATOMIC_INC(InFmt_MIMG*);
74170         ~Inst_MIMG__IMAGE_ATOMIC_INC();
74171
74172         int
74173         getNumOperands() override
74174         {
74175             return numDstRegOperands() + numSrcRegOperands();
74176         } // getNumOperands
74177
74178         int numDstRegOperands() override { return 1; }
74179         int numSrcRegOperands() override { return 2; }
74180
74181         int
74182         getOperandSize(int opIdx) override
74183         {
74184             switch (opIdx) {
74185               case 0: //vgpr_a
74186                 return 32;
74187               case 1: //sgpr_r
74188                 return 32;
74189               case 2: //vgpr_d
74190                 return 16;
74191               default:
74192                 fatal("op idx %i out of bounds\n", opIdx);
74193                 return -1;
74194             }
74195         } // getOperandSize
74196
74197         bool
74198         isSrcOperand(int opIdx) override
74199         {
74200             switch (opIdx) {
74201               case 0: //vgpr_a
74202                 return true;
74203               case 1: //sgpr_r
74204                 return true;
74205               case 2: //vgpr_d
74206                 return false;
74207               default:
74208                 fatal("op idx %i out of bounds\n", opIdx);
74209                 return false;
74210             }
74211         } // isSrcOperand
74212
74213         bool
74214         isDstOperand(int opIdx) override
74215         {
74216             switch (opIdx) {
74217               case 0: //vgpr_a
74218                 return false;
74219               case 1: //sgpr_r
74220                 return false;
74221               case 2: //vgpr_d
74222                 return true;
74223               default:
74224                 fatal("op idx %i out of bounds\n", opIdx);
74225                 return false;
74226             }
74227         } // isDstOperand
74228
74229         void execute(GPUDynInstPtr) override;
74230     }; // Inst_MIMG__IMAGE_ATOMIC_INC
74231
74232     class Inst_MIMG__IMAGE_ATOMIC_DEC : public Inst_MIMG
74233     {
74234       public:
74235         Inst_MIMG__IMAGE_ATOMIC_DEC(InFmt_MIMG*);
74236         ~Inst_MIMG__IMAGE_ATOMIC_DEC();
74237
74238         int
74239         getNumOperands() override
74240         {
74241             return numDstRegOperands() + numSrcRegOperands();
74242         } // getNumOperands
74243
74244         int numDstRegOperands() override { return 1; }
74245         int numSrcRegOperands() override { return 2; }
74246
74247         int
74248         getOperandSize(int opIdx) override
74249         {
74250             switch (opIdx) {
74251               case 0: //vgpr_a
74252                 return 32;
74253               case 1: //sgpr_r
74254                 return 32;
74255               case 2: //vgpr_d
74256                 return 16;
74257               default:
74258                 fatal("op idx %i out of bounds\n", opIdx);
74259                 return -1;
74260             }
74261         } // getOperandSize
74262
74263         bool
74264         isSrcOperand(int opIdx) override
74265         {
74266             switch (opIdx) {
74267               case 0: //vgpr_a
74268                 return true;
74269               case 1: //sgpr_r
74270                 return true;
74271               case 2: //vgpr_d
74272                 return false;
74273               default:
74274                 fatal("op idx %i out of bounds\n", opIdx);
74275                 return false;
74276             }
74277         } // isSrcOperand
74278
74279         bool
74280         isDstOperand(int opIdx) override
74281         {
74282             switch (opIdx) {
74283               case 0: //vgpr_a
74284                 return false;
74285               case 1: //sgpr_r
74286                 return false;
74287               case 2: //vgpr_d
74288                 return true;
74289               default:
74290                 fatal("op idx %i out of bounds\n", opIdx);
74291                 return false;
74292             }
74293         } // isDstOperand
74294
74295         void execute(GPUDynInstPtr) override;
74296     }; // Inst_MIMG__IMAGE_ATOMIC_DEC
74297
74298     class Inst_MIMG__IMAGE_SAMPLE : public Inst_MIMG
74299     {
74300       public:
74301         Inst_MIMG__IMAGE_SAMPLE(InFmt_MIMG*);
74302         ~Inst_MIMG__IMAGE_SAMPLE();
74303
74304         int
74305         getNumOperands() override
74306         {
74307             return numDstRegOperands() + numSrcRegOperands();
74308         } // getNumOperands
74309
74310         int numDstRegOperands() override { return 1; }
74311         int numSrcRegOperands() override { return 3; }
74312
74313         int
74314         getOperandSize(int opIdx) override
74315         {
74316             switch (opIdx) {
74317               case 0: //vgpr_a
74318                 return 4;
74319               case 1: //sgpr_r
74320                 return 32;
74321               case 2: //sgpr_s
74322                 return 4;
74323               case 3: //vgpr_d
74324                 return 16;
74325               default:
74326                 fatal("op idx %i out of bounds\n", opIdx);
74327                 return -1;
74328             }
74329         } // getOperandSize
74330
74331         bool
74332         isSrcOperand(int opIdx) override
74333         {
74334             switch (opIdx) {
74335               case 0: //vgpr_a
74336                 return true;
74337               case 1: //sgpr_r
74338                 return true;
74339               case 2: //sgpr_s
74340                 return true;
74341               case 3: //vgpr_d
74342                 return false;
74343               default:
74344                 fatal("op idx %i out of bounds\n", opIdx);
74345                 return false;
74346             }
74347         } // isSrcOperand
74348
74349         bool
74350         isDstOperand(int opIdx) override
74351         {
74352             switch (opIdx) {
74353               case 0: //vgpr_a
74354                 return false;
74355               case 1: //sgpr_r
74356                 return false;
74357               case 2: //sgpr_s
74358                 return false;
74359               case 3: //vgpr_d
74360                 return true;
74361               default:
74362                 fatal("op idx %i out of bounds\n", opIdx);
74363                 return false;
74364             }
74365         } // isDstOperand
74366
74367         void execute(GPUDynInstPtr) override;
74368     }; // Inst_MIMG__IMAGE_SAMPLE
74369
74370     class Inst_MIMG__IMAGE_SAMPLE_CL : public Inst_MIMG
74371     {
74372       public:
74373         Inst_MIMG__IMAGE_SAMPLE_CL(InFmt_MIMG*);
74374         ~Inst_MIMG__IMAGE_SAMPLE_CL();
74375
74376         int
74377         getNumOperands() override
74378         {
74379             return numDstRegOperands() + numSrcRegOperands();
74380         } // getNumOperands
74381
74382         int numDstRegOperands() override { return 1; }
74383         int numSrcRegOperands() override { return 3; }
74384
74385         int
74386         getOperandSize(int opIdx) override
74387         {
74388             switch (opIdx) {
74389               case 0: //vgpr_a
74390                 return 4;
74391               case 1: //sgpr_r
74392                 return 32;
74393               case 2: //sgpr_s
74394                 return 4;
74395               case 3: //vgpr_d
74396                 return 16;
74397               default:
74398                 fatal("op idx %i out of bounds\n", opIdx);
74399                 return -1;
74400             }
74401         } // getOperandSize
74402
74403         bool
74404         isSrcOperand(int opIdx) override
74405         {
74406             switch (opIdx) {
74407               case 0: //vgpr_a
74408                 return true;
74409               case 1: //sgpr_r
74410                 return true;
74411               case 2: //sgpr_s
74412                 return true;
74413               case 3: //vgpr_d
74414                 return false;
74415               default:
74416                 fatal("op idx %i out of bounds\n", opIdx);
74417                 return false;
74418             }
74419         } // isSrcOperand
74420
74421         bool
74422         isDstOperand(int opIdx) override
74423         {
74424             switch (opIdx) {
74425               case 0: //vgpr_a
74426                 return false;
74427               case 1: //sgpr_r
74428                 return false;
74429               case 2: //sgpr_s
74430                 return false;
74431               case 3: //vgpr_d
74432                 return true;
74433               default:
74434                 fatal("op idx %i out of bounds\n", opIdx);
74435                 return false;
74436             }
74437         } // isDstOperand
74438
74439         void execute(GPUDynInstPtr) override;
74440     }; // Inst_MIMG__IMAGE_SAMPLE_CL
74441
74442     class Inst_MIMG__IMAGE_SAMPLE_D : public Inst_MIMG
74443     {
74444       public:
74445         Inst_MIMG__IMAGE_SAMPLE_D(InFmt_MIMG*);
74446         ~Inst_MIMG__IMAGE_SAMPLE_D();
74447
74448         int
74449         getNumOperands() override
74450         {
74451             return numDstRegOperands() + numSrcRegOperands();
74452         } // getNumOperands
74453
74454         int numDstRegOperands() override { return 1; }
74455         int numSrcRegOperands() override { return 3; }
74456
74457         int
74458         getOperandSize(int opIdx) override
74459         {
74460             switch (opIdx) {
74461               case 0: //vgpr_a
74462                 return 4;
74463               case 1: //sgpr_r
74464                 return 32;
74465               case 2: //sgpr_s
74466                 return 4;
74467               case 3: //vgpr_d
74468                 return 16;
74469               default:
74470                 fatal("op idx %i out of bounds\n", opIdx);
74471                 return -1;
74472             }
74473         } // getOperandSize
74474
74475         bool
74476         isSrcOperand(int opIdx) override
74477         {
74478             switch (opIdx) {
74479               case 0: //vgpr_a
74480                 return true;
74481               case 1: //sgpr_r
74482                 return true;
74483               case 2: //sgpr_s
74484                 return true;
74485               case 3: //vgpr_d
74486                 return false;
74487               default:
74488                 fatal("op idx %i out of bounds\n", opIdx);
74489                 return false;
74490             }
74491         } // isSrcOperand
74492
74493         bool
74494         isDstOperand(int opIdx) override
74495         {
74496             switch (opIdx) {
74497               case 0: //vgpr_a
74498                 return false;
74499               case 1: //sgpr_r
74500                 return false;
74501               case 2: //sgpr_s
74502                 return false;
74503               case 3: //vgpr_d
74504                 return true;
74505               default:
74506                 fatal("op idx %i out of bounds\n", opIdx);
74507                 return false;
74508             }
74509         } // isDstOperand
74510
74511         void execute(GPUDynInstPtr) override;
74512     }; // Inst_MIMG__IMAGE_SAMPLE_D
74513
74514     class Inst_MIMG__IMAGE_SAMPLE_D_CL : public Inst_MIMG
74515     {
74516       public:
74517         Inst_MIMG__IMAGE_SAMPLE_D_CL(InFmt_MIMG*);
74518         ~Inst_MIMG__IMAGE_SAMPLE_D_CL();
74519
74520         int
74521         getNumOperands() override
74522         {
74523             return numDstRegOperands() + numSrcRegOperands();
74524         } // getNumOperands
74525
74526         int numDstRegOperands() override { return 1; }
74527         int numSrcRegOperands() override { return 3; }
74528
74529         int
74530         getOperandSize(int opIdx) override
74531         {
74532             switch (opIdx) {
74533               case 0: //vgpr_a
74534                 return 4;
74535               case 1: //sgpr_r
74536                 return 32;
74537               case 2: //sgpr_s
74538                 return 4;
74539               case 3: //vgpr_d
74540                 return 16;
74541               default:
74542                 fatal("op idx %i out of bounds\n", opIdx);
74543                 return -1;
74544             }
74545         } // getOperandSize
74546
74547         bool
74548         isSrcOperand(int opIdx) override
74549         {
74550             switch (opIdx) {
74551               case 0: //vgpr_a
74552                 return true;
74553               case 1: //sgpr_r
74554                 return true;
74555               case 2: //sgpr_s
74556                 return true;
74557               case 3: //vgpr_d
74558                 return false;
74559               default:
74560                 fatal("op idx %i out of bounds\n", opIdx);
74561                 return false;
74562             }
74563         } // isSrcOperand
74564
74565         bool
74566         isDstOperand(int opIdx) override
74567         {
74568             switch (opIdx) {
74569               case 0: //vgpr_a
74570                 return false;
74571               case 1: //sgpr_r
74572                 return false;
74573               case 2: //sgpr_s
74574                 return false;
74575               case 3: //vgpr_d
74576                 return true;
74577               default:
74578                 fatal("op idx %i out of bounds\n", opIdx);
74579                 return false;
74580             }
74581         } // isDstOperand
74582
74583         void execute(GPUDynInstPtr) override;
74584     }; // Inst_MIMG__IMAGE_SAMPLE_D_CL
74585
74586     class Inst_MIMG__IMAGE_SAMPLE_L : public Inst_MIMG
74587     {
74588       public:
74589         Inst_MIMG__IMAGE_SAMPLE_L(InFmt_MIMG*);
74590         ~Inst_MIMG__IMAGE_SAMPLE_L();
74591
74592         int
74593         getNumOperands() override
74594         {
74595             return numDstRegOperands() + numSrcRegOperands();
74596         } // getNumOperands
74597
74598         int numDstRegOperands() override { return 1; }
74599         int numSrcRegOperands() override { return 3; }
74600
74601         int
74602         getOperandSize(int opIdx) override
74603         {
74604             switch (opIdx) {
74605               case 0: //vgpr_a
74606                 return 4;
74607               case 1: //sgpr_r
74608                 return 32;
74609               case 2: //sgpr_s
74610                 return 4;
74611               case 3: //vgpr_d
74612                 return 16;
74613               default:
74614                 fatal("op idx %i out of bounds\n", opIdx);
74615                 return -1;
74616             }
74617         } // getOperandSize
74618
74619         bool
74620         isSrcOperand(int opIdx) override
74621         {
74622             switch (opIdx) {
74623               case 0: //vgpr_a
74624                 return true;
74625               case 1: //sgpr_r
74626                 return true;
74627               case 2: //sgpr_s
74628                 return true;
74629               case 3: //vgpr_d
74630                 return false;
74631               default:
74632                 fatal("op idx %i out of bounds\n", opIdx);
74633                 return false;
74634             }
74635         } // isSrcOperand
74636
74637         bool
74638         isDstOperand(int opIdx) override
74639         {
74640             switch (opIdx) {
74641               case 0: //vgpr_a
74642                 return false;
74643               case 1: //sgpr_r
74644                 return false;
74645               case 2: //sgpr_s
74646                 return false;
74647               case 3: //vgpr_d
74648                 return true;
74649               default:
74650                 fatal("op idx %i out of bounds\n", opIdx);
74651                 return false;
74652             }
74653         } // isDstOperand
74654
74655         void execute(GPUDynInstPtr) override;
74656     }; // Inst_MIMG__IMAGE_SAMPLE_L
74657
74658     class Inst_MIMG__IMAGE_SAMPLE_B : public Inst_MIMG
74659     {
74660       public:
74661         Inst_MIMG__IMAGE_SAMPLE_B(InFmt_MIMG*);
74662         ~Inst_MIMG__IMAGE_SAMPLE_B();
74663
74664         int
74665         getNumOperands() override
74666         {
74667             return numDstRegOperands() + numSrcRegOperands();
74668         } // getNumOperands
74669
74670         int numDstRegOperands() override { return 1; }
74671         int numSrcRegOperands() override { return 3; }
74672
74673         int
74674         getOperandSize(int opIdx) override
74675         {
74676             switch (opIdx) {
74677               case 0: //vgpr_a
74678                 return 4;
74679               case 1: //sgpr_r
74680                 return 32;
74681               case 2: //sgpr_s
74682                 return 4;
74683               case 3: //vgpr_d
74684                 return 16;
74685               default:
74686                 fatal("op idx %i out of bounds\n", opIdx);
74687                 return -1;
74688             }
74689         } // getOperandSize
74690
74691         bool
74692         isSrcOperand(int opIdx) override
74693         {
74694             switch (opIdx) {
74695               case 0: //vgpr_a
74696                 return true;
74697               case 1: //sgpr_r
74698                 return true;
74699               case 2: //sgpr_s
74700                 return true;
74701               case 3: //vgpr_d
74702                 return false;
74703               default:
74704                 fatal("op idx %i out of bounds\n", opIdx);
74705                 return false;
74706             }
74707         } // isSrcOperand
74708
74709         bool
74710         isDstOperand(int opIdx) override
74711         {
74712             switch (opIdx) {
74713               case 0: //vgpr_a
74714                 return false;
74715               case 1: //sgpr_r
74716                 return false;
74717               case 2: //sgpr_s
74718                 return false;
74719               case 3: //vgpr_d
74720                 return true;
74721               default:
74722                 fatal("op idx %i out of bounds\n", opIdx);
74723                 return false;
74724             }
74725         } // isDstOperand
74726
74727         void execute(GPUDynInstPtr) override;
74728     }; // Inst_MIMG__IMAGE_SAMPLE_B
74729
74730     class Inst_MIMG__IMAGE_SAMPLE_B_CL : public Inst_MIMG
74731     {
74732       public:
74733         Inst_MIMG__IMAGE_SAMPLE_B_CL(InFmt_MIMG*);
74734         ~Inst_MIMG__IMAGE_SAMPLE_B_CL();
74735
74736         int
74737         getNumOperands() override
74738         {
74739             return numDstRegOperands() + numSrcRegOperands();
74740         } // getNumOperands
74741
74742         int numDstRegOperands() override { return 1; }
74743         int numSrcRegOperands() override { return 3; }
74744
74745         int
74746         getOperandSize(int opIdx) override
74747         {
74748             switch (opIdx) {
74749               case 0: //vgpr_a
74750                 return 4;
74751               case 1: //sgpr_r
74752                 return 32;
74753               case 2: //sgpr_s
74754                 return 4;
74755               case 3: //vgpr_d
74756                 return 16;
74757               default:
74758                 fatal("op idx %i out of bounds\n", opIdx);
74759                 return -1;
74760             }
74761         } // getOperandSize
74762
74763         bool
74764         isSrcOperand(int opIdx) override
74765         {
74766             switch (opIdx) {
74767               case 0: //vgpr_a
74768                 return true;
74769               case 1: //sgpr_r
74770                 return true;
74771               case 2: //sgpr_s
74772                 return true;
74773               case 3: //vgpr_d
74774                 return false;
74775               default:
74776                 fatal("op idx %i out of bounds\n", opIdx);
74777                 return false;
74778             }
74779         } // isSrcOperand
74780
74781         bool
74782         isDstOperand(int opIdx) override
74783         {
74784             switch (opIdx) {
74785               case 0: //vgpr_a
74786                 return false;
74787               case 1: //sgpr_r
74788                 return false;
74789               case 2: //sgpr_s
74790                 return false;
74791               case 3: //vgpr_d
74792                 return true;
74793               default:
74794                 fatal("op idx %i out of bounds\n", opIdx);
74795                 return false;
74796             }
74797         } // isDstOperand
74798
74799         void execute(GPUDynInstPtr) override;
74800     }; // Inst_MIMG__IMAGE_SAMPLE_B_CL
74801
74802     class Inst_MIMG__IMAGE_SAMPLE_LZ : public Inst_MIMG
74803     {
74804       public:
74805         Inst_MIMG__IMAGE_SAMPLE_LZ(InFmt_MIMG*);
74806         ~Inst_MIMG__IMAGE_SAMPLE_LZ();
74807
74808         int
74809         getNumOperands() override
74810         {
74811             return numDstRegOperands() + numSrcRegOperands();
74812         } // getNumOperands
74813
74814         int numDstRegOperands() override { return 1; }
74815         int numSrcRegOperands() override { return 3; }
74816
74817         int
74818         getOperandSize(int opIdx) override
74819         {
74820             switch (opIdx) {
74821               case 0: //vgpr_a
74822                 return 4;
74823               case 1: //sgpr_r
74824                 return 32;
74825               case 2: //sgpr_s
74826                 return 4;
74827               case 3: //vgpr_d
74828                 return 16;
74829               default:
74830                 fatal("op idx %i out of bounds\n", opIdx);
74831                 return -1;
74832             }
74833         } // getOperandSize
74834
74835         bool
74836         isSrcOperand(int opIdx) override
74837         {
74838             switch (opIdx) {
74839               case 0: //vgpr_a
74840                 return true;
74841               case 1: //sgpr_r
74842                 return true;
74843               case 2: //sgpr_s
74844                 return true;
74845               case 3: //vgpr_d
74846                 return false;
74847               default:
74848                 fatal("op idx %i out of bounds\n", opIdx);
74849                 return false;
74850             }
74851         } // isSrcOperand
74852
74853         bool
74854         isDstOperand(int opIdx) override
74855         {
74856             switch (opIdx) {
74857               case 0: //vgpr_a
74858                 return false;
74859               case 1: //sgpr_r
74860                 return false;
74861               case 2: //sgpr_s
74862                 return false;
74863               case 3: //vgpr_d
74864                 return true;
74865               default:
74866                 fatal("op idx %i out of bounds\n", opIdx);
74867                 return false;
74868             }
74869         } // isDstOperand
74870
74871         void execute(GPUDynInstPtr) override;
74872     }; // Inst_MIMG__IMAGE_SAMPLE_LZ
74873
74874     class Inst_MIMG__IMAGE_SAMPLE_C : public Inst_MIMG
74875     {
74876       public:
74877         Inst_MIMG__IMAGE_SAMPLE_C(InFmt_MIMG*);
74878         ~Inst_MIMG__IMAGE_SAMPLE_C();
74879
74880         int
74881         getNumOperands() override
74882         {
74883             return numDstRegOperands() + numSrcRegOperands();
74884         } // getNumOperands
74885
74886         int numDstRegOperands() override { return 1; }
74887         int numSrcRegOperands() override { return 3; }
74888
74889         int
74890         getOperandSize(int opIdx) override
74891         {
74892             switch (opIdx) {
74893               case 0: //vgpr_a
74894                 return 4;
74895               case 1: //sgpr_r
74896                 return 32;
74897               case 2: //sgpr_s
74898                 return 4;
74899               case 3: //vgpr_d
74900                 return 16;
74901               default:
74902                 fatal("op idx %i out of bounds\n", opIdx);
74903                 return -1;
74904             }
74905         } // getOperandSize
74906
74907         bool
74908         isSrcOperand(int opIdx) override
74909         {
74910             switch (opIdx) {
74911               case 0: //vgpr_a
74912                 return true;
74913               case 1: //sgpr_r
74914                 return true;
74915               case 2: //sgpr_s
74916                 return true;
74917               case 3: //vgpr_d
74918                 return false;
74919               default:
74920                 fatal("op idx %i out of bounds\n", opIdx);
74921                 return false;
74922             }
74923         } // isSrcOperand
74924
74925         bool
74926         isDstOperand(int opIdx) override
74927         {
74928             switch (opIdx) {
74929               case 0: //vgpr_a
74930                 return false;
74931               case 1: //sgpr_r
74932                 return false;
74933               case 2: //sgpr_s
74934                 return false;
74935               case 3: //vgpr_d
74936                 return true;
74937               default:
74938                 fatal("op idx %i out of bounds\n", opIdx);
74939                 return false;
74940             }
74941         } // isDstOperand
74942
74943         void execute(GPUDynInstPtr) override;
74944     }; // Inst_MIMG__IMAGE_SAMPLE_C
74945
74946     class Inst_MIMG__IMAGE_SAMPLE_C_CL : public Inst_MIMG
74947     {
74948       public:
74949         Inst_MIMG__IMAGE_SAMPLE_C_CL(InFmt_MIMG*);
74950         ~Inst_MIMG__IMAGE_SAMPLE_C_CL();
74951
74952         int
74953         getNumOperands() override
74954         {
74955             return numDstRegOperands() + numSrcRegOperands();
74956         } // getNumOperands
74957
74958         int numDstRegOperands() override { return 1; }
74959         int numSrcRegOperands() override { return 3; }
74960
74961         int
74962         getOperandSize(int opIdx) override
74963         {
74964             switch (opIdx) {
74965               case 0: //vgpr_a
74966                 return 4;
74967               case 1: //sgpr_r
74968                 return 32;
74969               case 2: //sgpr_s
74970                 return 4;
74971               case 3: //vgpr_d
74972                 return 16;
74973               default:
74974                 fatal("op idx %i out of bounds\n", opIdx);
74975                 return -1;
74976             }
74977         } // getOperandSize
74978
74979         bool
74980         isSrcOperand(int opIdx) override
74981         {
74982             switch (opIdx) {
74983               case 0: //vgpr_a
74984                 return true;
74985               case 1: //sgpr_r
74986                 return true;
74987               case 2: //sgpr_s
74988                 return true;
74989               case 3: //vgpr_d
74990                 return false;
74991               default:
74992                 fatal("op idx %i out of bounds\n", opIdx);
74993                 return false;
74994             }
74995         } // isSrcOperand
74996
74997         bool
74998         isDstOperand(int opIdx) override
74999         {
75000             switch (opIdx) {
75001               case 0: //vgpr_a
75002                 return false;
75003               case 1: //sgpr_r
75004                 return false;
75005               case 2: //sgpr_s
75006                 return false;
75007               case 3: //vgpr_d
75008                 return true;
75009               default:
75010                 fatal("op idx %i out of bounds\n", opIdx);
75011                 return false;
75012             }
75013         } // isDstOperand
75014
75015         void execute(GPUDynInstPtr) override;
75016     }; // Inst_MIMG__IMAGE_SAMPLE_C_CL
75017
75018     class Inst_MIMG__IMAGE_SAMPLE_C_D : public Inst_MIMG
75019     {
75020       public:
75021         Inst_MIMG__IMAGE_SAMPLE_C_D(InFmt_MIMG*);
75022         ~Inst_MIMG__IMAGE_SAMPLE_C_D();
75023
75024         int
75025         getNumOperands() override
75026         {
75027             return numDstRegOperands() + numSrcRegOperands();
75028         } // getNumOperands
75029
75030         int numDstRegOperands() override { return 1; }
75031         int numSrcRegOperands() override { return 3; }
75032
75033         int
75034         getOperandSize(int opIdx) override
75035         {
75036             switch (opIdx) {
75037               case 0: //vgpr_a
75038                 return 4;
75039               case 1: //sgpr_r
75040                 return 32;
75041               case 2: //sgpr_s
75042                 return 4;
75043               case 3: //vgpr_d
75044                 return 16;
75045               default:
75046                 fatal("op idx %i out of bounds\n", opIdx);
75047                 return -1;
75048             }
75049         } // getOperandSize
75050
75051         bool
75052         isSrcOperand(int opIdx) override
75053         {
75054             switch (opIdx) {
75055               case 0: //vgpr_a
75056                 return true;
75057               case 1: //sgpr_r
75058                 return true;
75059               case 2: //sgpr_s
75060                 return true;
75061               case 3: //vgpr_d
75062                 return false;
75063               default:
75064                 fatal("op idx %i out of bounds\n", opIdx);
75065                 return false;
75066             }
75067         } // isSrcOperand
75068
75069         bool
75070         isDstOperand(int opIdx) override
75071         {
75072             switch (opIdx) {
75073               case 0: //vgpr_a
75074                 return false;
75075               case 1: //sgpr_r
75076                 return false;
75077               case 2: //sgpr_s
75078                 return false;
75079               case 3: //vgpr_d
75080                 return true;
75081               default:
75082                 fatal("op idx %i out of bounds\n", opIdx);
75083                 return false;
75084             }
75085         } // isDstOperand
75086
75087         void execute(GPUDynInstPtr) override;
75088     }; // Inst_MIMG__IMAGE_SAMPLE_C_D
75089
75090     class Inst_MIMG__IMAGE_SAMPLE_C_D_CL : public Inst_MIMG
75091     {
75092       public:
75093         Inst_MIMG__IMAGE_SAMPLE_C_D_CL(InFmt_MIMG*);
75094         ~Inst_MIMG__IMAGE_SAMPLE_C_D_CL();
75095
75096         int
75097         getNumOperands() override
75098         {
75099             return numDstRegOperands() + numSrcRegOperands();
75100         } // getNumOperands
75101
75102         int numDstRegOperands() override { return 1; }
75103         int numSrcRegOperands() override { return 3; }
75104
75105         int
75106         getOperandSize(int opIdx) override
75107         {
75108             switch (opIdx) {
75109               case 0: //vgpr_a
75110                 return 4;
75111               case 1: //sgpr_r
75112                 return 32;
75113               case 2: //sgpr_s
75114                 return 4;
75115               case 3: //vgpr_d
75116                 return 16;
75117               default:
75118                 fatal("op idx %i out of bounds\n", opIdx);
75119                 return -1;
75120             }
75121         } // getOperandSize
75122
75123         bool
75124         isSrcOperand(int opIdx) override
75125         {
75126             switch (opIdx) {
75127               case 0: //vgpr_a
75128                 return true;
75129               case 1: //sgpr_r
75130                 return true;
75131               case 2: //sgpr_s
75132                 return true;
75133               case 3: //vgpr_d
75134                 return false;
75135               default:
75136                 fatal("op idx %i out of bounds\n", opIdx);
75137                 return false;
75138             }
75139         } // isSrcOperand
75140
75141         bool
75142         isDstOperand(int opIdx) override
75143         {
75144             switch (opIdx) {
75145               case 0: //vgpr_a
75146                 return false;
75147               case 1: //sgpr_r
75148                 return false;
75149               case 2: //sgpr_s
75150                 return false;
75151               case 3: //vgpr_d
75152                 return true;
75153               default:
75154                 fatal("op idx %i out of bounds\n", opIdx);
75155                 return false;
75156             }
75157         } // isDstOperand
75158
75159         void execute(GPUDynInstPtr) override;
75160     }; // Inst_MIMG__IMAGE_SAMPLE_C_D_CL
75161
75162     class Inst_MIMG__IMAGE_SAMPLE_C_L : public Inst_MIMG
75163     {
75164       public:
75165         Inst_MIMG__IMAGE_SAMPLE_C_L(InFmt_MIMG*);
75166         ~Inst_MIMG__IMAGE_SAMPLE_C_L();
75167
75168         int
75169         getNumOperands() override
75170         {
75171             return numDstRegOperands() + numSrcRegOperands();
75172         } // getNumOperands
75173
75174         int numDstRegOperands() override { return 1; }
75175         int numSrcRegOperands() override { return 3; }
75176
75177         int
75178         getOperandSize(int opIdx) override
75179         {
75180             switch (opIdx) {
75181               case 0: //vgpr_a
75182                 return 4;
75183               case 1: //sgpr_r
75184                 return 32;
75185               case 2: //sgpr_s
75186                 return 4;
75187               case 3: //vgpr_d
75188                 return 16;
75189               default:
75190                 fatal("op idx %i out of bounds\n", opIdx);
75191                 return -1;
75192             }
75193         } // getOperandSize
75194
75195         bool
75196         isSrcOperand(int opIdx) override
75197         {
75198             switch (opIdx) {
75199               case 0: //vgpr_a
75200                 return true;
75201               case 1: //sgpr_r
75202                 return true;
75203               case 2: //sgpr_s
75204                 return true;
75205               case 3: //vgpr_d
75206                 return false;
75207               default:
75208                 fatal("op idx %i out of bounds\n", opIdx);
75209                 return false;
75210             }
75211         } // isSrcOperand
75212
75213         bool
75214         isDstOperand(int opIdx) override
75215         {
75216             switch (opIdx) {
75217               case 0: //vgpr_a
75218                 return false;
75219               case 1: //sgpr_r
75220                 return false;
75221               case 2: //sgpr_s
75222                 return false;
75223               case 3: //vgpr_d
75224                 return true;
75225               default:
75226                 fatal("op idx %i out of bounds\n", opIdx);
75227                 return false;
75228             }
75229         } // isDstOperand
75230
75231         void execute(GPUDynInstPtr) override;
75232     }; // Inst_MIMG__IMAGE_SAMPLE_C_L
75233
75234     class Inst_MIMG__IMAGE_SAMPLE_C_B : public Inst_MIMG
75235     {
75236       public:
75237         Inst_MIMG__IMAGE_SAMPLE_C_B(InFmt_MIMG*);
75238         ~Inst_MIMG__IMAGE_SAMPLE_C_B();
75239
75240         int
75241         getNumOperands() override
75242         {
75243             return numDstRegOperands() + numSrcRegOperands();
75244         } // getNumOperands
75245
75246         int numDstRegOperands() override { return 1; }
75247         int numSrcRegOperands() override { return 3; }
75248
75249         int
75250         getOperandSize(int opIdx) override
75251         {
75252             switch (opIdx) {
75253               case 0: //vgpr_a
75254                 return 4;
75255               case 1: //sgpr_r
75256                 return 32;
75257               case 2: //sgpr_s
75258                 return 4;
75259               case 3: //vgpr_d
75260                 return 16;
75261               default:
75262                 fatal("op idx %i out of bounds\n", opIdx);
75263                 return -1;
75264             }
75265         } // getOperandSize
75266
75267         bool
75268         isSrcOperand(int opIdx) override
75269         {
75270             switch (opIdx) {
75271               case 0: //vgpr_a
75272                 return true;
75273               case 1: //sgpr_r
75274                 return true;
75275               case 2: //sgpr_s
75276                 return true;
75277               case 3: //vgpr_d
75278                 return false;
75279               default:
75280                 fatal("op idx %i out of bounds\n", opIdx);
75281                 return false;
75282             }
75283         } // isSrcOperand
75284
75285         bool
75286         isDstOperand(int opIdx) override
75287         {
75288             switch (opIdx) {
75289               case 0: //vgpr_a
75290                 return false;
75291               case 1: //sgpr_r
75292                 return false;
75293               case 2: //sgpr_s
75294                 return false;
75295               case 3: //vgpr_d
75296                 return true;
75297               default:
75298                 fatal("op idx %i out of bounds\n", opIdx);
75299                 return false;
75300             }
75301         } // isDstOperand
75302
75303         void execute(GPUDynInstPtr) override;
75304     }; // Inst_MIMG__IMAGE_SAMPLE_C_B
75305
75306     class Inst_MIMG__IMAGE_SAMPLE_C_B_CL : public Inst_MIMG
75307     {
75308       public:
75309         Inst_MIMG__IMAGE_SAMPLE_C_B_CL(InFmt_MIMG*);
75310         ~Inst_MIMG__IMAGE_SAMPLE_C_B_CL();
75311
75312         int
75313         getNumOperands() override
75314         {
75315             return numDstRegOperands() + numSrcRegOperands();
75316         } // getNumOperands
75317
75318         int numDstRegOperands() override { return 1; }
75319         int numSrcRegOperands() override { return 3; }
75320
75321         int
75322         getOperandSize(int opIdx) override
75323         {
75324             switch (opIdx) {
75325               case 0: //vgpr_a
75326                 return 4;
75327               case 1: //sgpr_r
75328                 return 32;
75329               case 2: //sgpr_s
75330                 return 4;
75331               case 3: //vgpr_d
75332                 return 16;
75333               default:
75334                 fatal("op idx %i out of bounds\n", opIdx);
75335                 return -1;
75336             }
75337         } // getOperandSize
75338
75339         bool
75340         isSrcOperand(int opIdx) override
75341         {
75342             switch (opIdx) {
75343               case 0: //vgpr_a
75344                 return true;
75345               case 1: //sgpr_r
75346                 return true;
75347               case 2: //sgpr_s
75348                 return true;
75349               case 3: //vgpr_d
75350                 return false;
75351               default:
75352                 fatal("op idx %i out of bounds\n", opIdx);
75353                 return false;
75354             }
75355         } // isSrcOperand
75356
75357         bool
75358         isDstOperand(int opIdx) override
75359         {
75360             switch (opIdx) {
75361               case 0: //vgpr_a
75362                 return false;
75363               case 1: //sgpr_r
75364                 return false;
75365               case 2: //sgpr_s
75366                 return false;
75367               case 3: //vgpr_d
75368                 return true;
75369               default:
75370                 fatal("op idx %i out of bounds\n", opIdx);
75371                 return false;
75372             }
75373         } // isDstOperand
75374
75375         void execute(GPUDynInstPtr) override;
75376     }; // Inst_MIMG__IMAGE_SAMPLE_C_B_CL
75377
75378     class Inst_MIMG__IMAGE_SAMPLE_C_LZ : public Inst_MIMG
75379     {
75380       public:
75381         Inst_MIMG__IMAGE_SAMPLE_C_LZ(InFmt_MIMG*);
75382         ~Inst_MIMG__IMAGE_SAMPLE_C_LZ();
75383
75384         int
75385         getNumOperands() override
75386         {
75387             return numDstRegOperands() + numSrcRegOperands();
75388         } // getNumOperands
75389
75390         int numDstRegOperands() override { return 1; }
75391         int numSrcRegOperands() override { return 3; }
75392
75393         int
75394         getOperandSize(int opIdx) override
75395         {
75396             switch (opIdx) {
75397               case 0: //vgpr_a
75398                 return 4;
75399               case 1: //sgpr_r
75400                 return 32;
75401               case 2: //sgpr_s
75402                 return 4;
75403               case 3: //vgpr_d
75404                 return 16;
75405               default:
75406                 fatal("op idx %i out of bounds\n", opIdx);
75407                 return -1;
75408             }
75409         } // getOperandSize
75410
75411         bool
75412         isSrcOperand(int opIdx) override
75413         {
75414             switch (opIdx) {
75415               case 0: //vgpr_a
75416                 return true;
75417               case 1: //sgpr_r
75418                 return true;
75419               case 2: //sgpr_s
75420                 return true;
75421               case 3: //vgpr_d
75422                 return false;
75423               default:
75424                 fatal("op idx %i out of bounds\n", opIdx);
75425                 return false;
75426             }
75427         } // isSrcOperand
75428
75429         bool
75430         isDstOperand(int opIdx) override
75431         {
75432             switch (opIdx) {
75433               case 0: //vgpr_a
75434                 return false;
75435               case 1: //sgpr_r
75436                 return false;
75437               case 2: //sgpr_s
75438                 return false;
75439               case 3: //vgpr_d
75440                 return true;
75441               default:
75442                 fatal("op idx %i out of bounds\n", opIdx);
75443                 return false;
75444             }
75445         } // isDstOperand
75446
75447         void execute(GPUDynInstPtr) override;
75448     }; // Inst_MIMG__IMAGE_SAMPLE_C_LZ
75449
75450     class Inst_MIMG__IMAGE_SAMPLE_O : public Inst_MIMG
75451     {
75452       public:
75453         Inst_MIMG__IMAGE_SAMPLE_O(InFmt_MIMG*);
75454         ~Inst_MIMG__IMAGE_SAMPLE_O();
75455
75456         int
75457         getNumOperands() override
75458         {
75459             return numDstRegOperands() + numSrcRegOperands();
75460         } // getNumOperands
75461
75462         int numDstRegOperands() override { return 1; }
75463         int numSrcRegOperands() override { return 3; }
75464
75465         int
75466         getOperandSize(int opIdx) override
75467         {
75468             switch (opIdx) {
75469               case 0: //vgpr_a
75470                 return 4;
75471               case 1: //sgpr_r
75472                 return 32;
75473               case 2: //sgpr_s
75474                 return 4;
75475               case 3: //vgpr_d
75476                 return 16;
75477               default:
75478                 fatal("op idx %i out of bounds\n", opIdx);
75479                 return -1;
75480             }
75481         } // getOperandSize
75482
75483         bool
75484         isSrcOperand(int opIdx) override
75485         {
75486             switch (opIdx) {
75487               case 0: //vgpr_a
75488                 return true;
75489               case 1: //sgpr_r
75490                 return true;
75491               case 2: //sgpr_s
75492                 return true;
75493               case 3: //vgpr_d
75494                 return false;
75495               default:
75496                 fatal("op idx %i out of bounds\n", opIdx);
75497                 return false;
75498             }
75499         } // isSrcOperand
75500
75501         bool
75502         isDstOperand(int opIdx) override
75503         {
75504             switch (opIdx) {
75505               case 0: //vgpr_a
75506                 return false;
75507               case 1: //sgpr_r
75508                 return false;
75509               case 2: //sgpr_s
75510                 return false;
75511               case 3: //vgpr_d
75512                 return true;
75513               default:
75514                 fatal("op idx %i out of bounds\n", opIdx);
75515                 return false;
75516             }
75517         } // isDstOperand
75518
75519         void execute(GPUDynInstPtr) override;
75520     }; // Inst_MIMG__IMAGE_SAMPLE_O
75521
75522     class Inst_MIMG__IMAGE_SAMPLE_CL_O : public Inst_MIMG
75523     {
75524       public:
75525         Inst_MIMG__IMAGE_SAMPLE_CL_O(InFmt_MIMG*);
75526         ~Inst_MIMG__IMAGE_SAMPLE_CL_O();
75527
75528         int
75529         getNumOperands() override
75530         {
75531             return numDstRegOperands() + numSrcRegOperands();
75532         } // getNumOperands
75533
75534         int numDstRegOperands() override { return 1; }
75535         int numSrcRegOperands() override { return 3; }
75536
75537         int
75538         getOperandSize(int opIdx) override
75539         {
75540             switch (opIdx) {
75541               case 0: //vgpr_a
75542                 return 4;
75543               case 1: //sgpr_r
75544                 return 32;
75545               case 2: //sgpr_s
75546                 return 4;
75547               case 3: //vgpr_d
75548                 return 16;
75549               default:
75550                 fatal("op idx %i out of bounds\n", opIdx);
75551                 return -1;
75552             }
75553         } // getOperandSize
75554
75555         bool
75556         isSrcOperand(int opIdx) override
75557         {
75558             switch (opIdx) {
75559               case 0: //vgpr_a
75560                 return true;
75561               case 1: //sgpr_r
75562                 return true;
75563               case 2: //sgpr_s
75564                 return true;
75565               case 3: //vgpr_d
75566                 return false;
75567               default:
75568                 fatal("op idx %i out of bounds\n", opIdx);
75569                 return false;
75570             }
75571         } // isSrcOperand
75572
75573         bool
75574         isDstOperand(int opIdx) override
75575         {
75576             switch (opIdx) {
75577               case 0: //vgpr_a
75578                 return false;
75579               case 1: //sgpr_r
75580                 return false;
75581               case 2: //sgpr_s
75582                 return false;
75583               case 3: //vgpr_d
75584                 return true;
75585               default:
75586                 fatal("op idx %i out of bounds\n", opIdx);
75587                 return false;
75588             }
75589         } // isDstOperand
75590
75591         void execute(GPUDynInstPtr) override;
75592     }; // Inst_MIMG__IMAGE_SAMPLE_CL_O
75593
75594     class Inst_MIMG__IMAGE_SAMPLE_D_O : public Inst_MIMG
75595     {
75596       public:
75597         Inst_MIMG__IMAGE_SAMPLE_D_O(InFmt_MIMG*);
75598         ~Inst_MIMG__IMAGE_SAMPLE_D_O();
75599
75600         int
75601         getNumOperands() override
75602         {
75603             return numDstRegOperands() + numSrcRegOperands();
75604         } // getNumOperands
75605
75606         int numDstRegOperands() override { return 1; }
75607         int numSrcRegOperands() override { return 3; }
75608
75609         int
75610         getOperandSize(int opIdx) override
75611         {
75612             switch (opIdx) {
75613               case 0: //vgpr_a
75614                 return 4;
75615               case 1: //sgpr_r
75616                 return 32;
75617               case 2: //sgpr_s
75618                 return 4;
75619               case 3: //vgpr_d
75620                 return 16;
75621               default:
75622                 fatal("op idx %i out of bounds\n", opIdx);
75623                 return -1;
75624             }
75625         } // getOperandSize
75626
75627         bool
75628         isSrcOperand(int opIdx) override
75629         {
75630             switch (opIdx) {
75631               case 0: //vgpr_a
75632                 return true;
75633               case 1: //sgpr_r
75634                 return true;
75635               case 2: //sgpr_s
75636                 return true;
75637               case 3: //vgpr_d
75638                 return false;
75639               default:
75640                 fatal("op idx %i out of bounds\n", opIdx);
75641                 return false;
75642             }
75643         } // isSrcOperand
75644
75645         bool
75646         isDstOperand(int opIdx) override
75647         {
75648             switch (opIdx) {
75649               case 0: //vgpr_a
75650                 return false;
75651               case 1: //sgpr_r
75652                 return false;
75653               case 2: //sgpr_s
75654                 return false;
75655               case 3: //vgpr_d
75656                 return true;
75657               default:
75658                 fatal("op idx %i out of bounds\n", opIdx);
75659                 return false;
75660             }
75661         } // isDstOperand
75662
75663         void execute(GPUDynInstPtr) override;
75664     }; // Inst_MIMG__IMAGE_SAMPLE_D_O
75665
75666     class Inst_MIMG__IMAGE_SAMPLE_D_CL_O : public Inst_MIMG
75667     {
75668       public:
75669         Inst_MIMG__IMAGE_SAMPLE_D_CL_O(InFmt_MIMG*);
75670         ~Inst_MIMG__IMAGE_SAMPLE_D_CL_O();
75671
75672         int
75673         getNumOperands() override
75674         {
75675             return numDstRegOperands() + numSrcRegOperands();
75676         } // getNumOperands
75677
75678         int numDstRegOperands() override { return 1; }
75679         int numSrcRegOperands() override { return 3; }
75680
75681         int
75682         getOperandSize(int opIdx) override
75683         {
75684             switch (opIdx) {
75685               case 0: //vgpr_a
75686                 return 4;
75687               case 1: //sgpr_r
75688                 return 32;
75689               case 2: //sgpr_s
75690                 return 4;
75691               case 3: //vgpr_d
75692                 return 16;
75693               default:
75694                 fatal("op idx %i out of bounds\n", opIdx);
75695                 return -1;
75696             }
75697         } // getOperandSize
75698
75699         bool
75700         isSrcOperand(int opIdx) override
75701         {
75702             switch (opIdx) {
75703               case 0: //vgpr_a
75704                 return true;
75705               case 1: //sgpr_r
75706                 return true;
75707               case 2: //sgpr_s
75708                 return true;
75709               case 3: //vgpr_d
75710                 return false;
75711               default:
75712                 fatal("op idx %i out of bounds\n", opIdx);
75713                 return false;
75714             }
75715         } // isSrcOperand
75716
75717         bool
75718         isDstOperand(int opIdx) override
75719         {
75720             switch (opIdx) {
75721               case 0: //vgpr_a
75722                 return false;
75723               case 1: //sgpr_r
75724                 return false;
75725               case 2: //sgpr_s
75726                 return false;
75727               case 3: //vgpr_d
75728                 return true;
75729               default:
75730                 fatal("op idx %i out of bounds\n", opIdx);
75731                 return false;
75732             }
75733         } // isDstOperand
75734
75735         void execute(GPUDynInstPtr) override;
75736     }; // Inst_MIMG__IMAGE_SAMPLE_D_CL_O
75737
75738     class Inst_MIMG__IMAGE_SAMPLE_L_O : public Inst_MIMG
75739     {
75740       public:
75741         Inst_MIMG__IMAGE_SAMPLE_L_O(InFmt_MIMG*);
75742         ~Inst_MIMG__IMAGE_SAMPLE_L_O();
75743
75744         int
75745         getNumOperands() override
75746         {
75747             return numDstRegOperands() + numSrcRegOperands();
75748         } // getNumOperands
75749
75750         int numDstRegOperands() override { return 1; }
75751         int numSrcRegOperands() override { return 3; }
75752
75753         int
75754         getOperandSize(int opIdx) override
75755         {
75756             switch (opIdx) {
75757               case 0: //vgpr_a
75758                 return 4;
75759               case 1: //sgpr_r
75760                 return 32;
75761               case 2: //sgpr_s
75762                 return 4;
75763               case 3: //vgpr_d
75764                 return 16;
75765               default:
75766                 fatal("op idx %i out of bounds\n", opIdx);
75767                 return -1;
75768             }
75769         } // getOperandSize
75770
75771         bool
75772         isSrcOperand(int opIdx) override
75773         {
75774             switch (opIdx) {
75775               case 0: //vgpr_a
75776                 return true;
75777               case 1: //sgpr_r
75778                 return true;
75779               case 2: //sgpr_s
75780                 return true;
75781               case 3: //vgpr_d
75782                 return false;
75783               default:
75784                 fatal("op idx %i out of bounds\n", opIdx);
75785                 return false;
75786             }
75787         } // isSrcOperand
75788
75789         bool
75790         isDstOperand(int opIdx) override
75791         {
75792             switch (opIdx) {
75793               case 0: //vgpr_a
75794                 return false;
75795               case 1: //sgpr_r
75796                 return false;
75797               case 2: //sgpr_s
75798                 return false;
75799               case 3: //vgpr_d
75800                 return true;
75801               default:
75802                 fatal("op idx %i out of bounds\n", opIdx);
75803                 return false;
75804             }
75805         } // isDstOperand
75806
75807         void execute(GPUDynInstPtr) override;
75808     }; // Inst_MIMG__IMAGE_SAMPLE_L_O
75809
75810     class Inst_MIMG__IMAGE_SAMPLE_B_O : public Inst_MIMG
75811     {
75812       public:
75813         Inst_MIMG__IMAGE_SAMPLE_B_O(InFmt_MIMG*);
75814         ~Inst_MIMG__IMAGE_SAMPLE_B_O();
75815
75816         int
75817         getNumOperands() override
75818         {
75819             return numDstRegOperands() + numSrcRegOperands();
75820         } // getNumOperands
75821
75822         int numDstRegOperands() override { return 1; }
75823         int numSrcRegOperands() override { return 3; }
75824
75825         int
75826         getOperandSize(int opIdx) override
75827         {
75828             switch (opIdx) {
75829               case 0: //vgpr_a
75830                 return 4;
75831               case 1: //sgpr_r
75832                 return 32;
75833               case 2: //sgpr_s
75834                 return 4;
75835               case 3: //vgpr_d
75836                 return 16;
75837               default:
75838                 fatal("op idx %i out of bounds\n", opIdx);
75839                 return -1;
75840             }
75841         } // getOperandSize
75842
75843         bool
75844         isSrcOperand(int opIdx) override
75845         {
75846             switch (opIdx) {
75847               case 0: //vgpr_a
75848                 return true;
75849               case 1: //sgpr_r
75850                 return true;
75851               case 2: //sgpr_s
75852                 return true;
75853               case 3: //vgpr_d
75854                 return false;
75855               default:
75856                 fatal("op idx %i out of bounds\n", opIdx);
75857                 return false;
75858             }
75859         } // isSrcOperand
75860
75861         bool
75862         isDstOperand(int opIdx) override
75863         {
75864             switch (opIdx) {
75865               case 0: //vgpr_a
75866                 return false;
75867               case 1: //sgpr_r
75868                 return false;
75869               case 2: //sgpr_s
75870                 return false;
75871               case 3: //vgpr_d
75872                 return true;
75873               default:
75874                 fatal("op idx %i out of bounds\n", opIdx);
75875                 return false;
75876             }
75877         } // isDstOperand
75878
75879         void execute(GPUDynInstPtr) override;
75880     }; // Inst_MIMG__IMAGE_SAMPLE_B_O
75881
75882     class Inst_MIMG__IMAGE_SAMPLE_B_CL_O : public Inst_MIMG
75883     {
75884       public:
75885         Inst_MIMG__IMAGE_SAMPLE_B_CL_O(InFmt_MIMG*);
75886         ~Inst_MIMG__IMAGE_SAMPLE_B_CL_O();
75887
75888         int
75889         getNumOperands() override
75890         {
75891             return numDstRegOperands() + numSrcRegOperands();
75892         } // getNumOperands
75893
75894         int numDstRegOperands() override { return 1; }
75895         int numSrcRegOperands() override { return 3; }
75896
75897         int
75898         getOperandSize(int opIdx) override
75899         {
75900             switch (opIdx) {
75901               case 0: //vgpr_a
75902                 return 4;
75903               case 1: //sgpr_r
75904                 return 32;
75905               case 2: //sgpr_s
75906                 return 4;
75907               case 3: //vgpr_d
75908                 return 16;
75909               default:
75910                 fatal("op idx %i out of bounds\n", opIdx);
75911                 return -1;
75912             }
75913         } // getOperandSize
75914
75915         bool
75916         isSrcOperand(int opIdx) override
75917         {
75918             switch (opIdx) {
75919               case 0: //vgpr_a
75920                 return true;
75921               case 1: //sgpr_r
75922                 return true;
75923               case 2: //sgpr_s
75924                 return true;
75925               case 3: //vgpr_d
75926                 return false;
75927               default:
75928                 fatal("op idx %i out of bounds\n", opIdx);
75929                 return false;
75930             }
75931         } // isSrcOperand
75932
75933         bool
75934         isDstOperand(int opIdx) override
75935         {
75936             switch (opIdx) {
75937               case 0: //vgpr_a
75938                 return false;
75939               case 1: //sgpr_r
75940                 return false;
75941               case 2: //sgpr_s
75942                 return false;
75943               case 3: //vgpr_d
75944                 return true;
75945               default:
75946                 fatal("op idx %i out of bounds\n", opIdx);
75947                 return false;
75948             }
75949         } // isDstOperand
75950
75951         void execute(GPUDynInstPtr) override;
75952     }; // Inst_MIMG__IMAGE_SAMPLE_B_CL_O
75953
75954     class Inst_MIMG__IMAGE_SAMPLE_LZ_O : public Inst_MIMG
75955     {
75956       public:
75957         Inst_MIMG__IMAGE_SAMPLE_LZ_O(InFmt_MIMG*);
75958         ~Inst_MIMG__IMAGE_SAMPLE_LZ_O();
75959
75960         int
75961         getNumOperands() override
75962         {
75963             return numDstRegOperands() + numSrcRegOperands();
75964         } // getNumOperands
75965
75966         int numDstRegOperands() override { return 1; }
75967         int numSrcRegOperands() override { return 3; }
75968
75969         int
75970         getOperandSize(int opIdx) override
75971         {
75972             switch (opIdx) {
75973               case 0: //vgpr_a
75974                 return 4;
75975               case 1: //sgpr_r
75976                 return 32;
75977               case 2: //sgpr_s
75978                 return 4;
75979               case 3: //vgpr_d
75980                 return 16;
75981               default:
75982                 fatal("op idx %i out of bounds\n", opIdx);
75983                 return -1;
75984             }
75985         } // getOperandSize
75986
75987         bool
75988         isSrcOperand(int opIdx) override
75989         {
75990             switch (opIdx) {
75991               case 0: //vgpr_a
75992                 return true;
75993               case 1: //sgpr_r
75994                 return true;
75995               case 2: //sgpr_s
75996                 return true;
75997               case 3: //vgpr_d
75998                 return false;
75999               default:
76000                 fatal("op idx %i out of bounds\n", opIdx);
76001                 return false;
76002             }
76003         } // isSrcOperand
76004
76005         bool
76006         isDstOperand(int opIdx) override
76007         {
76008             switch (opIdx) {
76009               case 0: //vgpr_a
76010                 return false;
76011               case 1: //sgpr_r
76012                 return false;
76013               case 2: //sgpr_s
76014                 return false;
76015               case 3: //vgpr_d
76016                 return true;
76017               default:
76018                 fatal("op idx %i out of bounds\n", opIdx);
76019                 return false;
76020             }
76021         } // isDstOperand
76022
76023         void execute(GPUDynInstPtr) override;
76024     }; // Inst_MIMG__IMAGE_SAMPLE_LZ_O
76025
76026     class Inst_MIMG__IMAGE_SAMPLE_C_O : public Inst_MIMG
76027     {
76028       public:
76029         Inst_MIMG__IMAGE_SAMPLE_C_O(InFmt_MIMG*);
76030         ~Inst_MIMG__IMAGE_SAMPLE_C_O();
76031
76032         int
76033         getNumOperands() override
76034         {
76035             return numDstRegOperands() + numSrcRegOperands();
76036         } // getNumOperands
76037
76038         int numDstRegOperands() override { return 1; }
76039         int numSrcRegOperands() override { return 3; }
76040
76041         int
76042         getOperandSize(int opIdx) override
76043         {
76044             switch (opIdx) {
76045               case 0: //vgpr_a
76046                 return 4;
76047               case 1: //sgpr_r
76048                 return 32;
76049               case 2: //sgpr_s
76050                 return 4;
76051               case 3: //vgpr_d
76052                 return 16;
76053               default:
76054                 fatal("op idx %i out of bounds\n", opIdx);
76055                 return -1;
76056             }
76057         } // getOperandSize
76058
76059         bool
76060         isSrcOperand(int opIdx) override
76061         {
76062             switch (opIdx) {
76063               case 0: //vgpr_a
76064                 return true;
76065               case 1: //sgpr_r
76066                 return true;
76067               case 2: //sgpr_s
76068                 return true;
76069               case 3: //vgpr_d
76070                 return false;
76071               default:
76072                 fatal("op idx %i out of bounds\n", opIdx);
76073                 return false;
76074             }
76075         } // isSrcOperand
76076
76077         bool
76078         isDstOperand(int opIdx) override
76079         {
76080             switch (opIdx) {
76081               case 0: //vgpr_a
76082                 return false;
76083               case 1: //sgpr_r
76084                 return false;
76085               case 2: //sgpr_s
76086                 return false;
76087               case 3: //vgpr_d
76088                 return true;
76089               default:
76090                 fatal("op idx %i out of bounds\n", opIdx);
76091                 return false;
76092             }
76093         } // isDstOperand
76094
76095         void execute(GPUDynInstPtr) override;
76096     }; // Inst_MIMG__IMAGE_SAMPLE_C_O
76097
76098     class Inst_MIMG__IMAGE_SAMPLE_C_CL_O : public Inst_MIMG
76099     {
76100       public:
76101         Inst_MIMG__IMAGE_SAMPLE_C_CL_O(InFmt_MIMG*);
76102         ~Inst_MIMG__IMAGE_SAMPLE_C_CL_O();
76103
76104         int
76105         getNumOperands() override
76106         {
76107             return numDstRegOperands() + numSrcRegOperands();
76108         } // getNumOperands
76109
76110         int numDstRegOperands() override { return 1; }
76111         int numSrcRegOperands() override { return 3; }
76112
76113         int
76114         getOperandSize(int opIdx) override
76115         {
76116             switch (opIdx) {
76117               case 0: //vgpr_a
76118                 return 4;
76119               case 1: //sgpr_r
76120                 return 32;
76121               case 2: //sgpr_s
76122                 return 4;
76123               case 3: //vgpr_d
76124                 return 16;
76125               default:
76126                 fatal("op idx %i out of bounds\n", opIdx);
76127                 return -1;
76128             }
76129         } // getOperandSize
76130
76131         bool
76132         isSrcOperand(int opIdx) override
76133         {
76134             switch (opIdx) {
76135               case 0: //vgpr_a
76136                 return true;
76137               case 1: //sgpr_r
76138                 return true;
76139               case 2: //sgpr_s
76140                 return true;
76141               case 3: //vgpr_d
76142                 return false;
76143               default:
76144                 fatal("op idx %i out of bounds\n", opIdx);
76145                 return false;
76146             }
76147         } // isSrcOperand
76148
76149         bool
76150         isDstOperand(int opIdx) override
76151         {
76152             switch (opIdx) {
76153               case 0: //vgpr_a
76154                 return false;
76155               case 1: //sgpr_r
76156                 return false;
76157               case 2: //sgpr_s
76158                 return false;
76159               case 3: //vgpr_d
76160                 return true;
76161               default:
76162                 fatal("op idx %i out of bounds\n", opIdx);
76163                 return false;
76164             }
76165         } // isDstOperand
76166
76167         void execute(GPUDynInstPtr) override;
76168     }; // Inst_MIMG__IMAGE_SAMPLE_C_CL_O
76169
76170     class Inst_MIMG__IMAGE_SAMPLE_C_D_O : public Inst_MIMG
76171     {
76172       public:
76173         Inst_MIMG__IMAGE_SAMPLE_C_D_O(InFmt_MIMG*);
76174         ~Inst_MIMG__IMAGE_SAMPLE_C_D_O();
76175
76176         int
76177         getNumOperands() override
76178         {
76179             return numDstRegOperands() + numSrcRegOperands();
76180         } // getNumOperands
76181
76182         int numDstRegOperands() override { return 1; }
76183         int numSrcRegOperands() override { return 3; }
76184
76185         int
76186         getOperandSize(int opIdx) override
76187         {
76188             switch (opIdx) {
76189               case 0: //vgpr_a
76190                 return 4;
76191               case 1: //sgpr_r
76192                 return 32;
76193               case 2: //sgpr_s
76194                 return 4;
76195               case 3: //vgpr_d
76196                 return 16;
76197               default:
76198                 fatal("op idx %i out of bounds\n", opIdx);
76199                 return -1;
76200             }
76201         } // getOperandSize
76202
76203         bool
76204         isSrcOperand(int opIdx) override
76205         {
76206             switch (opIdx) {
76207               case 0: //vgpr_a
76208                 return true;
76209               case 1: //sgpr_r
76210                 return true;
76211               case 2: //sgpr_s
76212                 return true;
76213               case 3: //vgpr_d
76214                 return false;
76215               default:
76216                 fatal("op idx %i out of bounds\n", opIdx);
76217                 return false;
76218             }
76219         } // isSrcOperand
76220
76221         bool
76222         isDstOperand(int opIdx) override
76223         {
76224             switch (opIdx) {
76225               case 0: //vgpr_a
76226                 return false;
76227               case 1: //sgpr_r
76228                 return false;
76229               case 2: //sgpr_s
76230                 return false;
76231               case 3: //vgpr_d
76232                 return true;
76233               default:
76234                 fatal("op idx %i out of bounds\n", opIdx);
76235                 return false;
76236             }
76237         } // isDstOperand
76238
76239         void execute(GPUDynInstPtr) override;
76240     }; // Inst_MIMG__IMAGE_SAMPLE_C_D_O
76241
76242     class Inst_MIMG__IMAGE_SAMPLE_C_D_CL_O : public Inst_MIMG
76243     {
76244       public:
76245         Inst_MIMG__IMAGE_SAMPLE_C_D_CL_O(InFmt_MIMG*);
76246         ~Inst_MIMG__IMAGE_SAMPLE_C_D_CL_O();
76247
76248         int
76249         getNumOperands() override
76250         {
76251             return numDstRegOperands() + numSrcRegOperands();
76252         } // getNumOperands
76253
76254         int numDstRegOperands() override { return 1; }
76255         int numSrcRegOperands() override { return 3; }
76256
76257         int
76258         getOperandSize(int opIdx) override
76259         {
76260             switch (opIdx) {
76261               case 0: //vgpr_a
76262                 return 4;
76263               case 1: //sgpr_r
76264                 return 32;
76265               case 2: //sgpr_s
76266                 return 4;
76267               case 3: //vgpr_d
76268                 return 16;
76269               default:
76270                 fatal("op idx %i out of bounds\n", opIdx);
76271                 return -1;
76272             }
76273         } // getOperandSize
76274
76275         bool
76276         isSrcOperand(int opIdx) override
76277         {
76278             switch (opIdx) {
76279               case 0: //vgpr_a
76280                 return true;
76281               case 1: //sgpr_r
76282                 return true;
76283               case 2: //sgpr_s
76284                 return true;
76285               case 3: //vgpr_d
76286                 return false;
76287               default:
76288                 fatal("op idx %i out of bounds\n", opIdx);
76289                 return false;
76290             }
76291         } // isSrcOperand
76292
76293         bool
76294         isDstOperand(int opIdx) override
76295         {
76296             switch (opIdx) {
76297               case 0: //vgpr_a
76298                 return false;
76299               case 1: //sgpr_r
76300                 return false;
76301               case 2: //sgpr_s
76302                 return false;
76303               case 3: //vgpr_d
76304                 return true;
76305               default:
76306                 fatal("op idx %i out of bounds\n", opIdx);
76307                 return false;
76308             }
76309         } // isDstOperand
76310
76311         void execute(GPUDynInstPtr) override;
76312     }; // Inst_MIMG__IMAGE_SAMPLE_C_D_CL_O
76313
76314     class Inst_MIMG__IMAGE_SAMPLE_C_L_O : public Inst_MIMG
76315     {
76316       public:
76317         Inst_MIMG__IMAGE_SAMPLE_C_L_O(InFmt_MIMG*);
76318         ~Inst_MIMG__IMAGE_SAMPLE_C_L_O();
76319
76320         int
76321         getNumOperands() override
76322         {
76323             return numDstRegOperands() + numSrcRegOperands();
76324         } // getNumOperands
76325
76326         int numDstRegOperands() override { return 1; }
76327         int numSrcRegOperands() override { return 3; }
76328
76329         int
76330         getOperandSize(int opIdx) override
76331         {
76332             switch (opIdx) {
76333               case 0: //vgpr_a
76334                 return 4;
76335               case 1: //sgpr_r
76336                 return 32;
76337               case 2: //sgpr_s
76338                 return 4;
76339               case 3: //vgpr_d
76340                 return 16;
76341               default:
76342                 fatal("op idx %i out of bounds\n", opIdx);
76343                 return -1;
76344             }
76345         } // getOperandSize
76346
76347         bool
76348         isSrcOperand(int opIdx) override
76349         {
76350             switch (opIdx) {
76351               case 0: //vgpr_a
76352                 return true;
76353               case 1: //sgpr_r
76354                 return true;
76355               case 2: //sgpr_s
76356                 return true;
76357               case 3: //vgpr_d
76358                 return false;
76359               default:
76360                 fatal("op idx %i out of bounds\n", opIdx);
76361                 return false;
76362             }
76363         } // isSrcOperand
76364
76365         bool
76366         isDstOperand(int opIdx) override
76367         {
76368             switch (opIdx) {
76369               case 0: //vgpr_a
76370                 return false;
76371               case 1: //sgpr_r
76372                 return false;
76373               case 2: //sgpr_s
76374                 return false;
76375               case 3: //vgpr_d
76376                 return true;
76377               default:
76378                 fatal("op idx %i out of bounds\n", opIdx);
76379                 return false;
76380             }
76381         } // isDstOperand
76382
76383         void execute(GPUDynInstPtr) override;
76384     }; // Inst_MIMG__IMAGE_SAMPLE_C_L_O
76385
76386     class Inst_MIMG__IMAGE_SAMPLE_C_B_O : public Inst_MIMG
76387     {
76388       public:
76389         Inst_MIMG__IMAGE_SAMPLE_C_B_O(InFmt_MIMG*);
76390         ~Inst_MIMG__IMAGE_SAMPLE_C_B_O();
76391
76392         int
76393         getNumOperands() override
76394         {
76395             return numDstRegOperands() + numSrcRegOperands();
76396         } // getNumOperands
76397
76398         int numDstRegOperands() override { return 1; }
76399         int numSrcRegOperands() override { return 3; }
76400
76401         int
76402         getOperandSize(int opIdx) override
76403         {
76404             switch (opIdx) {
76405               case 0: //vgpr_a
76406                 return 4;
76407               case 1: //sgpr_r
76408                 return 32;
76409               case 2: //sgpr_s
76410                 return 4;
76411               case 3: //vgpr_d
76412                 return 16;
76413               default:
76414                 fatal("op idx %i out of bounds\n", opIdx);
76415                 return -1;
76416             }
76417         } // getOperandSize
76418
76419         bool
76420         isSrcOperand(int opIdx) override
76421         {
76422             switch (opIdx) {
76423               case 0: //vgpr_a
76424                 return true;
76425               case 1: //sgpr_r
76426                 return true;
76427               case 2: //sgpr_s
76428                 return true;
76429               case 3: //vgpr_d
76430                 return false;
76431               default:
76432                 fatal("op idx %i out of bounds\n", opIdx);
76433                 return false;
76434             }
76435         } // isSrcOperand
76436
76437         bool
76438         isDstOperand(int opIdx) override
76439         {
76440             switch (opIdx) {
76441               case 0: //vgpr_a
76442                 return false;
76443               case 1: //sgpr_r
76444                 return false;
76445               case 2: //sgpr_s
76446                 return false;
76447               case 3: //vgpr_d
76448                 return true;
76449               default:
76450                 fatal("op idx %i out of bounds\n", opIdx);
76451                 return false;
76452             }
76453         } // isDstOperand
76454
76455         void execute(GPUDynInstPtr) override;
76456     }; // Inst_MIMG__IMAGE_SAMPLE_C_B_O
76457
76458     class Inst_MIMG__IMAGE_SAMPLE_C_B_CL_O : public Inst_MIMG
76459     {
76460       public:
76461         Inst_MIMG__IMAGE_SAMPLE_C_B_CL_O(InFmt_MIMG*);
76462         ~Inst_MIMG__IMAGE_SAMPLE_C_B_CL_O();
76463
76464         int
76465         getNumOperands() override
76466         {
76467             return numDstRegOperands() + numSrcRegOperands();
76468         } // getNumOperands
76469
76470         int numDstRegOperands() override { return 1; }
76471         int numSrcRegOperands() override { return 3; }
76472
76473         int
76474         getOperandSize(int opIdx) override
76475         {
76476             switch (opIdx) {
76477               case 0: //vgpr_a
76478                 return 4;
76479               case 1: //sgpr_r
76480                 return 32;
76481               case 2: //sgpr_s
76482                 return 4;
76483               case 3: //vgpr_d
76484                 return 16;
76485               default:
76486                 fatal("op idx %i out of bounds\n", opIdx);
76487                 return -1;
76488             }
76489         } // getOperandSize
76490
76491         bool
76492         isSrcOperand(int opIdx) override
76493         {
76494             switch (opIdx) {
76495               case 0: //vgpr_a
76496                 return true;
76497               case 1: //sgpr_r
76498                 return true;
76499               case 2: //sgpr_s
76500                 return true;
76501               case 3: //vgpr_d
76502                 return false;
76503               default:
76504                 fatal("op idx %i out of bounds\n", opIdx);
76505                 return false;
76506             }
76507         } // isSrcOperand
76508
76509         bool
76510         isDstOperand(int opIdx) override
76511         {
76512             switch (opIdx) {
76513               case 0: //vgpr_a
76514                 return false;
76515               case 1: //sgpr_r
76516                 return false;
76517               case 2: //sgpr_s
76518                 return false;
76519               case 3: //vgpr_d
76520                 return true;
76521               default:
76522                 fatal("op idx %i out of bounds\n", opIdx);
76523                 return false;
76524             }
76525         } // isDstOperand
76526
76527         void execute(GPUDynInstPtr) override;
76528     }; // Inst_MIMG__IMAGE_SAMPLE_C_B_CL_O
76529
76530     class Inst_MIMG__IMAGE_SAMPLE_C_LZ_O : public Inst_MIMG
76531     {
76532       public:
76533         Inst_MIMG__IMAGE_SAMPLE_C_LZ_O(InFmt_MIMG*);
76534         ~Inst_MIMG__IMAGE_SAMPLE_C_LZ_O();
76535
76536         int
76537         getNumOperands() override
76538         {
76539             return numDstRegOperands() + numSrcRegOperands();
76540         } // getNumOperands
76541
76542         int numDstRegOperands() override { return 1; }
76543         int numSrcRegOperands() override { return 3; }
76544
76545         int
76546         getOperandSize(int opIdx) override
76547         {
76548             switch (opIdx) {
76549               case 0: //vgpr_a
76550                 return 4;
76551               case 1: //sgpr_r
76552                 return 32;
76553               case 2: //sgpr_s
76554                 return 4;
76555               case 3: //vgpr_d
76556                 return 16;
76557               default:
76558                 fatal("op idx %i out of bounds\n", opIdx);
76559                 return -1;
76560             }
76561         } // getOperandSize
76562
76563         bool
76564         isSrcOperand(int opIdx) override
76565         {
76566             switch (opIdx) {
76567               case 0: //vgpr_a
76568                 return true;
76569               case 1: //sgpr_r
76570                 return true;
76571               case 2: //sgpr_s
76572                 return true;
76573               case 3: //vgpr_d
76574                 return false;
76575               default:
76576                 fatal("op idx %i out of bounds\n", opIdx);
76577                 return false;
76578             }
76579         } // isSrcOperand
76580
76581         bool
76582         isDstOperand(int opIdx) override
76583         {
76584             switch (opIdx) {
76585               case 0: //vgpr_a
76586                 return false;
76587               case 1: //sgpr_r
76588                 return false;
76589               case 2: //sgpr_s
76590                 return false;
76591               case 3: //vgpr_d
76592                 return true;
76593               default:
76594                 fatal("op idx %i out of bounds\n", opIdx);
76595                 return false;
76596             }
76597         } // isDstOperand
76598
76599         void execute(GPUDynInstPtr) override;
76600     }; // Inst_MIMG__IMAGE_SAMPLE_C_LZ_O
76601
76602     class Inst_MIMG__IMAGE_GATHER4 : public Inst_MIMG
76603     {
76604       public:
76605         Inst_MIMG__IMAGE_GATHER4(InFmt_MIMG*);
76606         ~Inst_MIMG__IMAGE_GATHER4();
76607
76608         int
76609         getNumOperands() override
76610         {
76611             return numDstRegOperands() + numSrcRegOperands();
76612         } // getNumOperands
76613
76614         int numDstRegOperands() override { return 1; }
76615         int numSrcRegOperands() override { return 3; }
76616
76617         int
76618         getOperandSize(int opIdx) override
76619         {
76620             switch (opIdx) {
76621               case 0: //vgpr_a
76622                 return 4;
76623               case 1: //sgpr_r
76624                 return 32;
76625               case 2: //sgpr_s
76626                 return 4;
76627               case 3: //vgpr_d
76628                 return 16;
76629               default:
76630                 fatal("op idx %i out of bounds\n", opIdx);
76631                 return -1;
76632             }
76633         } // getOperandSize
76634
76635         bool
76636         isSrcOperand(int opIdx) override
76637         {
76638             switch (opIdx) {
76639               case 0: //vgpr_a
76640                 return true;
76641               case 1: //sgpr_r
76642                 return true;
76643               case 2: //sgpr_s
76644                 return true;
76645               case 3: //vgpr_d
76646                 return false;
76647               default:
76648                 fatal("op idx %i out of bounds\n", opIdx);
76649                 return false;
76650             }
76651         } // isSrcOperand
76652
76653         bool
76654         isDstOperand(int opIdx) override
76655         {
76656             switch (opIdx) {
76657               case 0: //vgpr_a
76658                 return false;
76659               case 1: //sgpr_r
76660                 return false;
76661               case 2: //sgpr_s
76662                 return false;
76663               case 3: //vgpr_d
76664                 return true;
76665               default:
76666                 fatal("op idx %i out of bounds\n", opIdx);
76667                 return false;
76668             }
76669         } // isDstOperand
76670
76671         void execute(GPUDynInstPtr) override;
76672     }; // Inst_MIMG__IMAGE_GATHER4
76673
76674     class Inst_MIMG__IMAGE_GATHER4_CL : public Inst_MIMG
76675     {
76676       public:
76677         Inst_MIMG__IMAGE_GATHER4_CL(InFmt_MIMG*);
76678         ~Inst_MIMG__IMAGE_GATHER4_CL();
76679
76680         int
76681         getNumOperands() override
76682         {
76683             return numDstRegOperands() + numSrcRegOperands();
76684         } // getNumOperands
76685
76686         int numDstRegOperands() override { return 1; }
76687         int numSrcRegOperands() override { return 3; }
76688
76689         int
76690         getOperandSize(int opIdx) override
76691         {
76692             switch (opIdx) {
76693               case 0: //vgpr_a
76694                 return 4;
76695               case 1: //sgpr_r
76696                 return 32;
76697               case 2: //sgpr_s
76698                 return 4;
76699               case 3: //vgpr_d
76700                 return 16;
76701               default:
76702                 fatal("op idx %i out of bounds\n", opIdx);
76703                 return -1;
76704             }
76705         } // getOperandSize
76706
76707         bool
76708         isSrcOperand(int opIdx) override
76709         {
76710             switch (opIdx) {
76711               case 0: //vgpr_a
76712                 return true;
76713               case 1: //sgpr_r
76714                 return true;
76715               case 2: //sgpr_s
76716                 return true;
76717               case 3: //vgpr_d
76718                 return false;
76719               default:
76720                 fatal("op idx %i out of bounds\n", opIdx);
76721                 return false;
76722             }
76723         } // isSrcOperand
76724
76725         bool
76726         isDstOperand(int opIdx) override
76727         {
76728             switch (opIdx) {
76729               case 0: //vgpr_a
76730                 return false;
76731               case 1: //sgpr_r
76732                 return false;
76733               case 2: //sgpr_s
76734                 return false;
76735               case 3: //vgpr_d
76736                 return true;
76737               default:
76738                 fatal("op idx %i out of bounds\n", opIdx);
76739                 return false;
76740             }
76741         } // isDstOperand
76742
76743         void execute(GPUDynInstPtr) override;
76744     }; // Inst_MIMG__IMAGE_GATHER4_CL
76745
76746     class Inst_MIMG__IMAGE_GATHER4_L : public Inst_MIMG
76747     {
76748       public:
76749         Inst_MIMG__IMAGE_GATHER4_L(InFmt_MIMG*);
76750         ~Inst_MIMG__IMAGE_GATHER4_L();
76751
76752         int
76753         getNumOperands() override
76754         {
76755             return numDstRegOperands() + numSrcRegOperands();
76756         } // getNumOperands
76757
76758         int numDstRegOperands() override { return 1; }
76759         int numSrcRegOperands() override { return 3; }
76760
76761         int
76762         getOperandSize(int opIdx) override
76763         {
76764             switch (opIdx) {
76765               case 0: //vgpr_a
76766                 return 4;
76767               case 1: //sgpr_r
76768                 return 32;
76769               case 2: //sgpr_s
76770                 return 4;
76771               case 3: //vgpr_d
76772                 return 16;
76773               default:
76774                 fatal("op idx %i out of bounds\n", opIdx);
76775                 return -1;
76776             }
76777         } // getOperandSize
76778
76779         bool
76780         isSrcOperand(int opIdx) override
76781         {
76782             switch (opIdx) {
76783               case 0: //vgpr_a
76784                 return true;
76785               case 1: //sgpr_r
76786                 return true;
76787               case 2: //sgpr_s
76788                 return true;
76789               case 3: //vgpr_d
76790                 return false;
76791               default:
76792                 fatal("op idx %i out of bounds\n", opIdx);
76793                 return false;
76794             }
76795         } // isSrcOperand
76796
76797         bool
76798         isDstOperand(int opIdx) override
76799         {
76800             switch (opIdx) {
76801               case 0: //vgpr_a
76802                 return false;
76803               case 1: //sgpr_r
76804                 return false;
76805               case 2: //sgpr_s
76806                 return false;
76807               case 3: //vgpr_d
76808                 return true;
76809               default:
76810                 fatal("op idx %i out of bounds\n", opIdx);
76811                 return false;
76812             }
76813         } // isDstOperand
76814
76815         void execute(GPUDynInstPtr) override;
76816     }; // Inst_MIMG__IMAGE_GATHER4_L
76817
76818     class Inst_MIMG__IMAGE_GATHER4_B : public Inst_MIMG
76819     {
76820       public:
76821         Inst_MIMG__IMAGE_GATHER4_B(InFmt_MIMG*);
76822         ~Inst_MIMG__IMAGE_GATHER4_B();
76823
76824         int
76825         getNumOperands() override
76826         {
76827             return numDstRegOperands() + numSrcRegOperands();
76828         } // getNumOperands
76829
76830         int numDstRegOperands() override { return 1; }
76831         int numSrcRegOperands() override { return 3; }
76832
76833         int
76834         getOperandSize(int opIdx) override
76835         {
76836             switch (opIdx) {
76837               case 0: //vgpr_a
76838                 return 4;
76839               case 1: //sgpr_r
76840                 return 32;
76841               case 2: //sgpr_s
76842                 return 4;
76843               case 3: //vgpr_d
76844                 return 16;
76845               default:
76846                 fatal("op idx %i out of bounds\n", opIdx);
76847                 return -1;
76848             }
76849         } // getOperandSize
76850
76851         bool
76852         isSrcOperand(int opIdx) override
76853         {
76854             switch (opIdx) {
76855               case 0: //vgpr_a
76856                 return true;
76857               case 1: //sgpr_r
76858                 return true;
76859               case 2: //sgpr_s
76860                 return true;
76861               case 3: //vgpr_d
76862                 return false;
76863               default:
76864                 fatal("op idx %i out of bounds\n", opIdx);
76865                 return false;
76866             }
76867         } // isSrcOperand
76868
76869         bool
76870         isDstOperand(int opIdx) override
76871         {
76872             switch (opIdx) {
76873               case 0: //vgpr_a
76874                 return false;
76875               case 1: //sgpr_r
76876                 return false;
76877               case 2: //sgpr_s
76878                 return false;
76879               case 3: //vgpr_d
76880                 return true;
76881               default:
76882                 fatal("op idx %i out of bounds\n", opIdx);
76883                 return false;
76884             }
76885         } // isDstOperand
76886
76887         void execute(GPUDynInstPtr) override;
76888     }; // Inst_MIMG__IMAGE_GATHER4_B
76889
76890     class Inst_MIMG__IMAGE_GATHER4_B_CL : public Inst_MIMG
76891     {
76892       public:
76893         Inst_MIMG__IMAGE_GATHER4_B_CL(InFmt_MIMG*);
76894         ~Inst_MIMG__IMAGE_GATHER4_B_CL();
76895
76896         int
76897         getNumOperands() override
76898         {
76899             return numDstRegOperands() + numSrcRegOperands();
76900         } // getNumOperands
76901
76902         int numDstRegOperands() override { return 1; }
76903         int numSrcRegOperands() override { return 3; }
76904
76905         int
76906         getOperandSize(int opIdx) override
76907         {
76908             switch (opIdx) {
76909               case 0: //vgpr_a
76910                 return 4;
76911               case 1: //sgpr_r
76912                 return 32;
76913               case 2: //sgpr_s
76914                 return 4;
76915               case 3: //vgpr_d
76916                 return 16;
76917               default:
76918                 fatal("op idx %i out of bounds\n", opIdx);
76919                 return -1;
76920             }
76921         } // getOperandSize
76922
76923         bool
76924         isSrcOperand(int opIdx) override
76925         {
76926             switch (opIdx) {
76927               case 0: //vgpr_a
76928                 return true;
76929               case 1: //sgpr_r
76930                 return true;
76931               case 2: //sgpr_s
76932                 return true;
76933               case 3: //vgpr_d
76934                 return false;
76935               default:
76936                 fatal("op idx %i out of bounds\n", opIdx);
76937                 return false;
76938             }
76939         } // isSrcOperand
76940
76941         bool
76942         isDstOperand(int opIdx) override
76943         {
76944             switch (opIdx) {
76945               case 0: //vgpr_a
76946                 return false;
76947               case 1: //sgpr_r
76948                 return false;
76949               case 2: //sgpr_s
76950                 return false;
76951               case 3: //vgpr_d
76952                 return true;
76953               default:
76954                 fatal("op idx %i out of bounds\n", opIdx);
76955                 return false;
76956             }
76957         } // isDstOperand
76958
76959         void execute(GPUDynInstPtr) override;
76960     }; // Inst_MIMG__IMAGE_GATHER4_B_CL
76961
76962     class Inst_MIMG__IMAGE_GATHER4_LZ : public Inst_MIMG
76963     {
76964       public:
76965         Inst_MIMG__IMAGE_GATHER4_LZ(InFmt_MIMG*);
76966         ~Inst_MIMG__IMAGE_GATHER4_LZ();
76967
76968         int
76969         getNumOperands() override
76970         {
76971             return numDstRegOperands() + numSrcRegOperands();
76972         } // getNumOperands
76973
76974         int numDstRegOperands() override { return 1; }
76975         int numSrcRegOperands() override { return 3; }
76976
76977         int
76978         getOperandSize(int opIdx) override
76979         {
76980             switch (opIdx) {
76981               case 0: //vgpr_a
76982                 return 4;
76983               case 1: //sgpr_r
76984                 return 32;
76985               case 2: //sgpr_s
76986                 return 4;
76987               case 3: //vgpr_d
76988                 return 16;
76989               default:
76990                 fatal("op idx %i out of bounds\n", opIdx);
76991                 return -1;
76992             }
76993         } // getOperandSize
76994
76995         bool
76996         isSrcOperand(int opIdx) override
76997         {
76998             switch (opIdx) {
76999               case 0: //vgpr_a
77000                 return true;
77001               case 1: //sgpr_r
77002                 return true;
77003               case 2: //sgpr_s
77004                 return true;
77005               case 3: //vgpr_d
77006                 return false;
77007               default:
77008                 fatal("op idx %i out of bounds\n", opIdx);
77009                 return false;
77010             }
77011         } // isSrcOperand
77012
77013         bool
77014         isDstOperand(int opIdx) override
77015         {
77016             switch (opIdx) {
77017               case 0: //vgpr_a
77018                 return false;
77019               case 1: //sgpr_r
77020                 return false;
77021               case 2: //sgpr_s
77022                 return false;
77023               case 3: //vgpr_d
77024                 return true;
77025               default:
77026                 fatal("op idx %i out of bounds\n", opIdx);
77027                 return false;
77028             }
77029         } // isDstOperand
77030
77031         void execute(GPUDynInstPtr) override;
77032     }; // Inst_MIMG__IMAGE_GATHER4_LZ
77033
77034     class Inst_MIMG__IMAGE_GATHER4_C : public Inst_MIMG
77035     {
77036       public:
77037         Inst_MIMG__IMAGE_GATHER4_C(InFmt_MIMG*);
77038         ~Inst_MIMG__IMAGE_GATHER4_C();
77039
77040         int
77041         getNumOperands() override
77042         {
77043             return numDstRegOperands() + numSrcRegOperands();
77044         } // getNumOperands
77045
77046         int numDstRegOperands() override { return 1; }
77047         int numSrcRegOperands() override { return 3; }
77048
77049         int
77050         getOperandSize(int opIdx) override
77051         {
77052             switch (opIdx) {
77053               case 0: //vgpr_a
77054                 return 4;
77055               case 1: //sgpr_r
77056                 return 32;
77057               case 2: //sgpr_s
77058                 return 4;
77059               case 3: //vgpr_d
77060                 return 16;
77061               default:
77062                 fatal("op idx %i out of bounds\n", opIdx);
77063                 return -1;
77064             }
77065         } // getOperandSize
77066
77067         bool
77068         isSrcOperand(int opIdx) override
77069         {
77070             switch (opIdx) {
77071               case 0: //vgpr_a
77072                 return true;
77073               case 1: //sgpr_r
77074                 return true;
77075               case 2: //sgpr_s
77076                 return true;
77077               case 3: //vgpr_d
77078                 return false;
77079               default:
77080                 fatal("op idx %i out of bounds\n", opIdx);
77081                 return false;
77082             }
77083         } // isSrcOperand
77084
77085         bool
77086         isDstOperand(int opIdx) override
77087         {
77088             switch (opIdx) {
77089               case 0: //vgpr_a
77090                 return false;
77091               case 1: //sgpr_r
77092                 return false;
77093               case 2: //sgpr_s
77094                 return false;
77095               case 3: //vgpr_d
77096                 return true;
77097               default:
77098                 fatal("op idx %i out of bounds\n", opIdx);
77099                 return false;
77100             }
77101         } // isDstOperand
77102
77103         void execute(GPUDynInstPtr) override;
77104     }; // Inst_MIMG__IMAGE_GATHER4_C
77105
77106     class Inst_MIMG__IMAGE_GATHER4_C_CL : public Inst_MIMG
77107     {
77108       public:
77109         Inst_MIMG__IMAGE_GATHER4_C_CL(InFmt_MIMG*);
77110         ~Inst_MIMG__IMAGE_GATHER4_C_CL();
77111
77112         int
77113         getNumOperands() override
77114         {
77115             return numDstRegOperands() + numSrcRegOperands();
77116         } // getNumOperands
77117
77118         int numDstRegOperands() override { return 1; }
77119         int numSrcRegOperands() override { return 3; }
77120
77121         int
77122         getOperandSize(int opIdx) override
77123         {
77124             switch (opIdx) {
77125               case 0: //vgpr_a
77126                 return 4;
77127               case 1: //sgpr_r
77128                 return 32;
77129               case 2: //sgpr_s
77130                 return 4;
77131               case 3: //vgpr_d
77132                 return 16;
77133               default:
77134                 fatal("op idx %i out of bounds\n", opIdx);
77135                 return -1;
77136             }
77137         } // getOperandSize
77138
77139         bool
77140         isSrcOperand(int opIdx) override
77141         {
77142             switch (opIdx) {
77143               case 0: //vgpr_a
77144                 return true;
77145               case 1: //sgpr_r
77146                 return true;
77147               case 2: //sgpr_s
77148                 return true;
77149               case 3: //vgpr_d
77150                 return false;
77151               default:
77152                 fatal("op idx %i out of bounds\n", opIdx);
77153                 return false;
77154             }
77155         } // isSrcOperand
77156
77157         bool
77158         isDstOperand(int opIdx) override
77159         {
77160             switch (opIdx) {
77161               case 0: //vgpr_a
77162                 return false;
77163               case 1: //sgpr_r
77164                 return false;
77165               case 2: //sgpr_s
77166                 return false;
77167               case 3: //vgpr_d
77168                 return true;
77169               default:
77170                 fatal("op idx %i out of bounds\n", opIdx);
77171                 return false;
77172             }
77173         } // isDstOperand
77174
77175         void execute(GPUDynInstPtr) override;
77176     }; // Inst_MIMG__IMAGE_GATHER4_C_CL
77177
77178     class Inst_MIMG__IMAGE_GATHER4_C_L : public Inst_MIMG
77179     {
77180       public:
77181         Inst_MIMG__IMAGE_GATHER4_C_L(InFmt_MIMG*);
77182         ~Inst_MIMG__IMAGE_GATHER4_C_L();
77183
77184         int
77185         getNumOperands() override
77186         {
77187             return numDstRegOperands() + numSrcRegOperands();
77188         } // getNumOperands
77189
77190         int numDstRegOperands() override { return 1; }
77191         int numSrcRegOperands() override { return 3; }
77192
77193         int
77194         getOperandSize(int opIdx) override
77195         {
77196             switch (opIdx) {
77197               case 0: //vgpr_a
77198                 return 4;
77199               case 1: //sgpr_r
77200                 return 32;
77201               case 2: //sgpr_s
77202                 return 4;
77203               case 3: //vgpr_d
77204                 return 16;
77205               default:
77206                 fatal("op idx %i out of bounds\n", opIdx);
77207                 return -1;
77208             }
77209         } // getOperandSize
77210
77211         bool
77212         isSrcOperand(int opIdx) override
77213         {
77214             switch (opIdx) {
77215               case 0: //vgpr_a
77216                 return true;
77217               case 1: //sgpr_r
77218                 return true;
77219               case 2: //sgpr_s
77220                 return true;
77221               case 3: //vgpr_d
77222                 return false;
77223               default:
77224                 fatal("op idx %i out of bounds\n", opIdx);
77225                 return false;
77226             }
77227         } // isSrcOperand
77228
77229         bool
77230         isDstOperand(int opIdx) override
77231         {
77232             switch (opIdx) {
77233               case 0: //vgpr_a
77234                 return false;
77235               case 1: //sgpr_r
77236                 return false;
77237               case 2: //sgpr_s
77238                 return false;
77239               case 3: //vgpr_d
77240                 return true;
77241               default:
77242                 fatal("op idx %i out of bounds\n", opIdx);
77243                 return false;
77244             }
77245         } // isDstOperand
77246
77247         void execute(GPUDynInstPtr) override;
77248     }; // Inst_MIMG__IMAGE_GATHER4_C_L
77249
77250     class Inst_MIMG__IMAGE_GATHER4_C_B : public Inst_MIMG
77251     {
77252       public:
77253         Inst_MIMG__IMAGE_GATHER4_C_B(InFmt_MIMG*);
77254         ~Inst_MIMG__IMAGE_GATHER4_C_B();
77255
77256         int
77257         getNumOperands() override
77258         {
77259             return numDstRegOperands() + numSrcRegOperands();
77260         } // getNumOperands
77261
77262         int numDstRegOperands() override { return 1; }
77263         int numSrcRegOperands() override { return 3; }
77264
77265         int
77266         getOperandSize(int opIdx) override
77267         {
77268             switch (opIdx) {
77269               case 0: //vgpr_a
77270                 return 4;
77271               case 1: //sgpr_r
77272                 return 32;
77273               case 2: //sgpr_s
77274                 return 4;
77275               case 3: //vgpr_d
77276                 return 16;
77277               default:
77278                 fatal("op idx %i out of bounds\n", opIdx);
77279                 return -1;
77280             }
77281         } // getOperandSize
77282
77283         bool
77284         isSrcOperand(int opIdx) override
77285         {
77286             switch (opIdx) {
77287               case 0: //vgpr_a
77288                 return true;
77289               case 1: //sgpr_r
77290                 return true;
77291               case 2: //sgpr_s
77292                 return true;
77293               case 3: //vgpr_d
77294                 return false;
77295               default:
77296                 fatal("op idx %i out of bounds\n", opIdx);
77297                 return false;
77298             }
77299         } // isSrcOperand
77300
77301         bool
77302         isDstOperand(int opIdx) override
77303         {
77304             switch (opIdx) {
77305               case 0: //vgpr_a
77306                 return false;
77307               case 1: //sgpr_r
77308                 return false;
77309               case 2: //sgpr_s
77310                 return false;
77311               case 3: //vgpr_d
77312                 return true;
77313               default:
77314                 fatal("op idx %i out of bounds\n", opIdx);
77315                 return false;
77316             }
77317         } // isDstOperand
77318
77319         void execute(GPUDynInstPtr) override;
77320     }; // Inst_MIMG__IMAGE_GATHER4_C_B
77321
77322     class Inst_MIMG__IMAGE_GATHER4_C_B_CL : public Inst_MIMG
77323     {
77324       public:
77325         Inst_MIMG__IMAGE_GATHER4_C_B_CL(InFmt_MIMG*);
77326         ~Inst_MIMG__IMAGE_GATHER4_C_B_CL();
77327
77328         int
77329         getNumOperands() override
77330         {
77331             return numDstRegOperands() + numSrcRegOperands();
77332         } // getNumOperands
77333
77334         int numDstRegOperands() override { return 1; }
77335         int numSrcRegOperands() override { return 3; }
77336
77337         int
77338         getOperandSize(int opIdx) override
77339         {
77340             switch (opIdx) {
77341               case 0: //vgpr_a
77342                 return 4;
77343               case 1: //sgpr_r
77344                 return 32;
77345               case 2: //sgpr_s
77346                 return 4;
77347               case 3: //vgpr_d
77348                 return 16;
77349               default:
77350                 fatal("op idx %i out of bounds\n", opIdx);
77351                 return -1;
77352             }
77353         } // getOperandSize
77354
77355         bool
77356         isSrcOperand(int opIdx) override
77357         {
77358             switch (opIdx) {
77359               case 0: //vgpr_a
77360                 return true;
77361               case 1: //sgpr_r
77362                 return true;
77363               case 2: //sgpr_s
77364                 return true;
77365               case 3: //vgpr_d
77366                 return false;
77367               default:
77368                 fatal("op idx %i out of bounds\n", opIdx);
77369                 return false;
77370             }
77371         } // isSrcOperand
77372
77373         bool
77374         isDstOperand(int opIdx) override
77375         {
77376             switch (opIdx) {
77377               case 0: //vgpr_a
77378                 return false;
77379               case 1: //sgpr_r
77380                 return false;
77381               case 2: //sgpr_s
77382                 return false;
77383               case 3: //vgpr_d
77384                 return true;
77385               default:
77386                 fatal("op idx %i out of bounds\n", opIdx);
77387                 return false;
77388             }
77389         } // isDstOperand
77390
77391         void execute(GPUDynInstPtr) override;
77392     }; // Inst_MIMG__IMAGE_GATHER4_C_B_CL
77393
77394     class Inst_MIMG__IMAGE_GATHER4_C_LZ : public Inst_MIMG
77395     {
77396       public:
77397         Inst_MIMG__IMAGE_GATHER4_C_LZ(InFmt_MIMG*);
77398         ~Inst_MIMG__IMAGE_GATHER4_C_LZ();
77399
77400         int
77401         getNumOperands() override
77402         {
77403             return numDstRegOperands() + numSrcRegOperands();
77404         } // getNumOperands
77405
77406         int numDstRegOperands() override { return 1; }
77407         int numSrcRegOperands() override { return 3; }
77408
77409         int
77410         getOperandSize(int opIdx) override
77411         {
77412             switch (opIdx) {
77413               case 0: //vgpr_a
77414                 return 4;
77415               case 1: //sgpr_r
77416                 return 32;
77417               case 2: //sgpr_s
77418                 return 4;
77419               case 3: //vgpr_d
77420                 return 16;
77421               default:
77422                 fatal("op idx %i out of bounds\n", opIdx);
77423                 return -1;
77424             }
77425         } // getOperandSize
77426
77427         bool
77428         isSrcOperand(int opIdx) override
77429         {
77430             switch (opIdx) {
77431               case 0: //vgpr_a
77432                 return true;
77433               case 1: //sgpr_r
77434                 return true;
77435               case 2: //sgpr_s
77436                 return true;
77437               case 3: //vgpr_d
77438                 return false;
77439               default:
77440                 fatal("op idx %i out of bounds\n", opIdx);
77441                 return false;
77442             }
77443         } // isSrcOperand
77444
77445         bool
77446         isDstOperand(int opIdx) override
77447         {
77448             switch (opIdx) {
77449               case 0: //vgpr_a
77450                 return false;
77451               case 1: //sgpr_r
77452                 return false;
77453               case 2: //sgpr_s
77454                 return false;
77455               case 3: //vgpr_d
77456                 return true;
77457               default:
77458                 fatal("op idx %i out of bounds\n", opIdx);
77459                 return false;
77460             }
77461         } // isDstOperand
77462
77463         void execute(GPUDynInstPtr) override;
77464     }; // Inst_MIMG__IMAGE_GATHER4_C_LZ
77465
77466     class Inst_MIMG__IMAGE_GATHER4_O : public Inst_MIMG
77467     {
77468       public:
77469         Inst_MIMG__IMAGE_GATHER4_O(InFmt_MIMG*);
77470         ~Inst_MIMG__IMAGE_GATHER4_O();
77471
77472         int
77473         getNumOperands() override
77474         {
77475             return numDstRegOperands() + numSrcRegOperands();
77476         } // getNumOperands
77477
77478         int numDstRegOperands() override { return 1; }
77479         int numSrcRegOperands() override { return 3; }
77480
77481         int
77482         getOperandSize(int opIdx) override
77483         {
77484             switch (opIdx) {
77485               case 0: //vgpr_a
77486                 return 4;
77487               case 1: //sgpr_r
77488                 return 32;
77489               case 2: //sgpr_s
77490                 return 4;
77491               case 3: //vgpr_d
77492                 return 16;
77493               default:
77494                 fatal("op idx %i out of bounds\n", opIdx);
77495                 return -1;
77496             }
77497         } // getOperandSize
77498
77499         bool
77500         isSrcOperand(int opIdx) override
77501         {
77502             switch (opIdx) {
77503               case 0: //vgpr_a
77504                 return true;
77505               case 1: //sgpr_r
77506                 return true;
77507               case 2: //sgpr_s
77508                 return true;
77509               case 3: //vgpr_d
77510                 return false;
77511               default:
77512                 fatal("op idx %i out of bounds\n", opIdx);
77513                 return false;
77514             }
77515         } // isSrcOperand
77516
77517         bool
77518         isDstOperand(int opIdx) override
77519         {
77520             switch (opIdx) {
77521               case 0: //vgpr_a
77522                 return false;
77523               case 1: //sgpr_r
77524                 return false;
77525               case 2: //sgpr_s
77526                 return false;
77527               case 3: //vgpr_d
77528                 return true;
77529               default:
77530                 fatal("op idx %i out of bounds\n", opIdx);
77531                 return false;
77532             }
77533         } // isDstOperand
77534
77535         void execute(GPUDynInstPtr) override;
77536     }; // Inst_MIMG__IMAGE_GATHER4_O
77537
77538     class Inst_MIMG__IMAGE_GATHER4_CL_O : public Inst_MIMG
77539     {
77540       public:
77541         Inst_MIMG__IMAGE_GATHER4_CL_O(InFmt_MIMG*);
77542         ~Inst_MIMG__IMAGE_GATHER4_CL_O();
77543
77544         int
77545         getNumOperands() override
77546         {
77547             return numDstRegOperands() + numSrcRegOperands();
77548         } // getNumOperands
77549
77550         int numDstRegOperands() override { return 1; }
77551         int numSrcRegOperands() override { return 3; }
77552
77553         int
77554         getOperandSize(int opIdx) override
77555         {
77556             switch (opIdx) {
77557               case 0: //vgpr_a
77558                 return 4;
77559               case 1: //sgpr_r
77560                 return 32;
77561               case 2: //sgpr_s
77562                 return 4;
77563               case 3: //vgpr_d
77564                 return 16;
77565               default:
77566                 fatal("op idx %i out of bounds\n", opIdx);
77567                 return -1;
77568             }
77569         } // getOperandSize
77570
77571         bool
77572         isSrcOperand(int opIdx) override
77573         {
77574             switch (opIdx) {
77575               case 0: //vgpr_a
77576                 return true;
77577               case 1: //sgpr_r
77578                 return true;
77579               case 2: //sgpr_s
77580                 return true;
77581               case 3: //vgpr_d
77582                 return false;
77583               default:
77584                 fatal("op idx %i out of bounds\n", opIdx);
77585                 return false;
77586             }
77587         } // isSrcOperand
77588
77589         bool
77590         isDstOperand(int opIdx) override
77591         {
77592             switch (opIdx) {
77593               case 0: //vgpr_a
77594                 return false;
77595               case 1: //sgpr_r
77596                 return false;
77597               case 2: //sgpr_s
77598                 return false;
77599               case 3: //vgpr_d
77600                 return true;
77601               default:
77602                 fatal("op idx %i out of bounds\n", opIdx);
77603                 return false;
77604             }
77605         } // isDstOperand
77606
77607         void execute(GPUDynInstPtr) override;
77608     }; // Inst_MIMG__IMAGE_GATHER4_CL_O
77609
77610     class Inst_MIMG__IMAGE_GATHER4_L_O : public Inst_MIMG
77611     {
77612       public:
77613         Inst_MIMG__IMAGE_GATHER4_L_O(InFmt_MIMG*);
77614         ~Inst_MIMG__IMAGE_GATHER4_L_O();
77615
77616         int
77617         getNumOperands() override
77618         {
77619             return numDstRegOperands() + numSrcRegOperands();
77620         } // getNumOperands
77621
77622         int numDstRegOperands() override { return 1; }
77623         int numSrcRegOperands() override { return 3; }
77624
77625         int
77626         getOperandSize(int opIdx) override
77627         {
77628             switch (opIdx) {
77629               case 0: //vgpr_a
77630                 return 4;
77631               case 1: //sgpr_r
77632                 return 32;
77633               case 2: //sgpr_s
77634                 return 4;
77635               case 3: //vgpr_d
77636                 return 16;
77637               default:
77638                 fatal("op idx %i out of bounds\n", opIdx);
77639                 return -1;
77640             }
77641         } // getOperandSize
77642
77643         bool
77644         isSrcOperand(int opIdx) override
77645         {
77646             switch (opIdx) {
77647               case 0: //vgpr_a
77648                 return true;
77649               case 1: //sgpr_r
77650                 return true;
77651               case 2: //sgpr_s
77652                 return true;
77653               case 3: //vgpr_d
77654                 return false;
77655               default:
77656                 fatal("op idx %i out of bounds\n", opIdx);
77657                 return false;
77658             }
77659         } // isSrcOperand
77660
77661         bool
77662         isDstOperand(int opIdx) override
77663         {
77664             switch (opIdx) {
77665               case 0: //vgpr_a
77666                 return false;
77667               case 1: //sgpr_r
77668                 return false;
77669               case 2: //sgpr_s
77670                 return false;
77671               case 3: //vgpr_d
77672                 return true;
77673               default:
77674                 fatal("op idx %i out of bounds\n", opIdx);
77675                 return false;
77676             }
77677         } // isDstOperand
77678
77679         void execute(GPUDynInstPtr) override;
77680     }; // Inst_MIMG__IMAGE_GATHER4_L_O
77681
77682     class Inst_MIMG__IMAGE_GATHER4_B_O : public Inst_MIMG
77683     {
77684       public:
77685         Inst_MIMG__IMAGE_GATHER4_B_O(InFmt_MIMG*);
77686         ~Inst_MIMG__IMAGE_GATHER4_B_O();
77687
77688         int
77689         getNumOperands() override
77690         {
77691             return numDstRegOperands() + numSrcRegOperands();
77692         } // getNumOperands
77693
77694         int numDstRegOperands() override { return 1; }
77695         int numSrcRegOperands() override { return 3; }
77696
77697         int
77698         getOperandSize(int opIdx) override
77699         {
77700             switch (opIdx) {
77701               case 0: //vgpr_a
77702                 return 4;
77703               case 1: //sgpr_r
77704                 return 32;
77705               case 2: //sgpr_s
77706                 return 4;
77707               case 3: //vgpr_d
77708                 return 16;
77709               default:
77710                 fatal("op idx %i out of bounds\n", opIdx);
77711                 return -1;
77712             }
77713         } // getOperandSize
77714
77715         bool
77716         isSrcOperand(int opIdx) override
77717         {
77718             switch (opIdx) {
77719               case 0: //vgpr_a
77720                 return true;
77721               case 1: //sgpr_r
77722                 return true;
77723               case 2: //sgpr_s
77724                 return true;
77725               case 3: //vgpr_d
77726                 return false;
77727               default:
77728                 fatal("op idx %i out of bounds\n", opIdx);
77729                 return false;
77730             }
77731         } // isSrcOperand
77732
77733         bool
77734         isDstOperand(int opIdx) override
77735         {
77736             switch (opIdx) {
77737               case 0: //vgpr_a
77738                 return false;
77739               case 1: //sgpr_r
77740                 return false;
77741               case 2: //sgpr_s
77742                 return false;
77743               case 3: //vgpr_d
77744                 return true;
77745               default:
77746                 fatal("op idx %i out of bounds\n", opIdx);
77747                 return false;
77748             }
77749         } // isDstOperand
77750
77751         void execute(GPUDynInstPtr) override;
77752     }; // Inst_MIMG__IMAGE_GATHER4_B_O
77753
77754     class Inst_MIMG__IMAGE_GATHER4_B_CL_O : public Inst_MIMG
77755     {
77756       public:
77757         Inst_MIMG__IMAGE_GATHER4_B_CL_O(InFmt_MIMG*);
77758         ~Inst_MIMG__IMAGE_GATHER4_B_CL_O();
77759
77760         int
77761         getNumOperands() override
77762         {
77763             return numDstRegOperands() + numSrcRegOperands();
77764         } // getNumOperands
77765
77766         int numDstRegOperands() override { return 1; }
77767         int numSrcRegOperands() override { return 3; }
77768
77769         int
77770         getOperandSize(int opIdx) override
77771         {
77772             switch (opIdx) {
77773               case 0: //vgpr_a
77774                 return 4;
77775               case 1: //sgpr_r
77776                 return 32;
77777               case 2: //sgpr_s
77778                 return 4;
77779               case 3: //vgpr_d
77780                 return 16;
77781               default:
77782                 fatal("op idx %i out of bounds\n", opIdx);
77783                 return -1;
77784             }
77785         } // getOperandSize
77786
77787         bool
77788         isSrcOperand(int opIdx) override
77789         {
77790             switch (opIdx) {
77791               case 0: //vgpr_a
77792                 return true;
77793               case 1: //sgpr_r
77794                 return true;
77795               case 2: //sgpr_s
77796                 return true;
77797               case 3: //vgpr_d
77798                 return false;
77799               default:
77800                 fatal("op idx %i out of bounds\n", opIdx);
77801                 return false;
77802             }
77803         } // isSrcOperand
77804
77805         bool
77806         isDstOperand(int opIdx) override
77807         {
77808             switch (opIdx) {
77809               case 0: //vgpr_a
77810                 return false;
77811               case 1: //sgpr_r
77812                 return false;
77813               case 2: //sgpr_s
77814                 return false;
77815               case 3: //vgpr_d
77816                 return true;
77817               default:
77818                 fatal("op idx %i out of bounds\n", opIdx);
77819                 return false;
77820             }
77821         } // isDstOperand
77822
77823         void execute(GPUDynInstPtr) override;
77824     }; // Inst_MIMG__IMAGE_GATHER4_B_CL_O
77825
77826     class Inst_MIMG__IMAGE_GATHER4_LZ_O : public Inst_MIMG
77827     {
77828       public:
77829         Inst_MIMG__IMAGE_GATHER4_LZ_O(InFmt_MIMG*);
77830         ~Inst_MIMG__IMAGE_GATHER4_LZ_O();
77831
77832         int
77833         getNumOperands() override
77834         {
77835             return numDstRegOperands() + numSrcRegOperands();
77836         } // getNumOperands
77837
77838         int numDstRegOperands() override { return 1; }
77839         int numSrcRegOperands() override { return 3; }
77840
77841         int
77842         getOperandSize(int opIdx) override
77843         {
77844             switch (opIdx) {
77845               case 0: //vgpr_a
77846                 return 4;
77847               case 1: //sgpr_r
77848                 return 32;
77849               case 2: //sgpr_s
77850                 return 4;
77851               case 3: //vgpr_d
77852                 return 16;
77853               default:
77854                 fatal("op idx %i out of bounds\n", opIdx);
77855                 return -1;
77856             }
77857         } // getOperandSize
77858
77859         bool
77860         isSrcOperand(int opIdx) override
77861         {
77862             switch (opIdx) {
77863               case 0: //vgpr_a
77864                 return true;
77865               case 1: //sgpr_r
77866                 return true;
77867               case 2: //sgpr_s
77868                 return true;
77869               case 3: //vgpr_d
77870                 return false;
77871               default:
77872                 fatal("op idx %i out of bounds\n", opIdx);
77873                 return false;
77874             }
77875         } // isSrcOperand
77876
77877         bool
77878         isDstOperand(int opIdx) override
77879         {
77880             switch (opIdx) {
77881               case 0: //vgpr_a
77882                 return false;
77883               case 1: //sgpr_r
77884                 return false;
77885               case 2: //sgpr_s
77886                 return false;
77887               case 3: //vgpr_d
77888                 return true;
77889               default:
77890                 fatal("op idx %i out of bounds\n", opIdx);
77891                 return false;
77892             }
77893         } // isDstOperand
77894
77895         void execute(GPUDynInstPtr) override;
77896     }; // Inst_MIMG__IMAGE_GATHER4_LZ_O
77897
77898     class Inst_MIMG__IMAGE_GATHER4_C_O : public Inst_MIMG
77899     {
77900       public:
77901         Inst_MIMG__IMAGE_GATHER4_C_O(InFmt_MIMG*);
77902         ~Inst_MIMG__IMAGE_GATHER4_C_O();
77903
77904         int
77905         getNumOperands() override
77906         {
77907             return numDstRegOperands() + numSrcRegOperands();
77908         } // getNumOperands
77909
77910         int numDstRegOperands() override { return 1; }
77911         int numSrcRegOperands() override { return 3; }
77912
77913         int
77914         getOperandSize(int opIdx) override
77915         {
77916             switch (opIdx) {
77917               case 0: //vgpr_a
77918                 return 4;
77919               case 1: //sgpr_r
77920                 return 32;
77921               case 2: //sgpr_s
77922                 return 4;
77923               case 3: //vgpr_d
77924                 return 16;
77925               default:
77926                 fatal("op idx %i out of bounds\n", opIdx);
77927                 return -1;
77928             }
77929         } // getOperandSize
77930
77931         bool
77932         isSrcOperand(int opIdx) override
77933         {
77934             switch (opIdx) {
77935               case 0: //vgpr_a
77936                 return true;
77937               case 1: //sgpr_r
77938                 return true;
77939               case 2: //sgpr_s
77940                 return true;
77941               case 3: //vgpr_d
77942                 return false;
77943               default:
77944                 fatal("op idx %i out of bounds\n", opIdx);
77945                 return false;
77946             }
77947         } // isSrcOperand
77948
77949         bool
77950         isDstOperand(int opIdx) override
77951         {
77952             switch (opIdx) {
77953               case 0: //vgpr_a
77954                 return false;
77955               case 1: //sgpr_r
77956                 return false;
77957               case 2: //sgpr_s
77958                 return false;
77959               case 3: //vgpr_d
77960                 return true;
77961               default:
77962                 fatal("op idx %i out of bounds\n", opIdx);
77963                 return false;
77964             }
77965         } // isDstOperand
77966
77967         void execute(GPUDynInstPtr) override;
77968     }; // Inst_MIMG__IMAGE_GATHER4_C_O
77969
77970     class Inst_MIMG__IMAGE_GATHER4_C_CL_O : public Inst_MIMG
77971     {
77972       public:
77973         Inst_MIMG__IMAGE_GATHER4_C_CL_O(InFmt_MIMG*);
77974         ~Inst_MIMG__IMAGE_GATHER4_C_CL_O();
77975
77976         int
77977         getNumOperands() override
77978         {
77979             return numDstRegOperands() + numSrcRegOperands();
77980         } // getNumOperands
77981
77982         int numDstRegOperands() override { return 1; }
77983         int numSrcRegOperands() override { return 3; }
77984
77985         int
77986         getOperandSize(int opIdx) override
77987         {
77988             switch (opIdx) {
77989               case 0: //vgpr_a
77990                 return 4;
77991               case 1: //sgpr_r
77992                 return 32;
77993               case 2: //sgpr_s
77994                 return 4;
77995               case 3: //vgpr_d
77996                 return 16;
77997               default:
77998                 fatal("op idx %i out of bounds\n", opIdx);
77999                 return -1;
78000             }
78001         } // getOperandSize
78002
78003         bool
78004         isSrcOperand(int opIdx) override
78005         {
78006             switch (opIdx) {
78007               case 0: //vgpr_a
78008                 return true;
78009               case 1: //sgpr_r
78010                 return true;
78011               case 2: //sgpr_s
78012                 return true;
78013               case 3: //vgpr_d
78014                 return false;
78015               default:
78016                 fatal("op idx %i out of bounds\n", opIdx);
78017                 return false;
78018             }
78019         } // isSrcOperand
78020
78021         bool
78022         isDstOperand(int opIdx) override
78023         {
78024             switch (opIdx) {
78025               case 0: //vgpr_a
78026                 return false;
78027               case 1: //sgpr_r
78028                 return false;
78029               case 2: //sgpr_s
78030                 return false;
78031               case 3: //vgpr_d
78032                 return true;
78033               default:
78034                 fatal("op idx %i out of bounds\n", opIdx);
78035                 return false;
78036             }
78037         } // isDstOperand
78038
78039         void execute(GPUDynInstPtr) override;
78040     }; // Inst_MIMG__IMAGE_GATHER4_C_CL_O
78041
78042     class Inst_MIMG__IMAGE_GATHER4_C_L_O : public Inst_MIMG
78043     {
78044       public:
78045         Inst_MIMG__IMAGE_GATHER4_C_L_O(InFmt_MIMG*);
78046         ~Inst_MIMG__IMAGE_GATHER4_C_L_O();
78047
78048         int
78049         getNumOperands() override
78050         {
78051             return numDstRegOperands() + numSrcRegOperands();
78052         } // getNumOperands
78053
78054         int numDstRegOperands() override { return 1; }
78055         int numSrcRegOperands() override { return 3; }
78056
78057         int
78058         getOperandSize(int opIdx) override
78059         {
78060             switch (opIdx) {
78061               case 0: //vgpr_a
78062                 return 4;
78063               case 1: //sgpr_r
78064                 return 32;
78065               case 2: //sgpr_s
78066                 return 4;
78067               case 3: //vgpr_d
78068                 return 16;
78069               default:
78070                 fatal("op idx %i out of bounds\n", opIdx);
78071                 return -1;
78072             }
78073         } // getOperandSize
78074
78075         bool
78076         isSrcOperand(int opIdx) override
78077         {
78078             switch (opIdx) {
78079               case 0: //vgpr_a
78080                 return true;
78081               case 1: //sgpr_r
78082                 return true;
78083               case 2: //sgpr_s
78084                 return true;
78085               case 3: //vgpr_d
78086                 return false;
78087               default:
78088                 fatal("op idx %i out of bounds\n", opIdx);
78089                 return false;
78090             }
78091         } // isSrcOperand
78092
78093         bool
78094         isDstOperand(int opIdx) override
78095         {
78096             switch (opIdx) {
78097               case 0: //vgpr_a
78098                 return false;
78099               case 1: //sgpr_r
78100                 return false;
78101               case 2: //sgpr_s
78102                 return false;
78103               case 3: //vgpr_d
78104                 return true;
78105               default:
78106                 fatal("op idx %i out of bounds\n", opIdx);
78107                 return false;
78108             }
78109         } // isDstOperand
78110
78111         void execute(GPUDynInstPtr) override;
78112     }; // Inst_MIMG__IMAGE_GATHER4_C_L_O
78113
78114     class Inst_MIMG__IMAGE_GATHER4_C_B_O : public Inst_MIMG
78115     {
78116       public:
78117         Inst_MIMG__IMAGE_GATHER4_C_B_O(InFmt_MIMG*);
78118         ~Inst_MIMG__IMAGE_GATHER4_C_B_O();
78119
78120         int
78121         getNumOperands() override
78122         {
78123             return numDstRegOperands() + numSrcRegOperands();
78124         } // getNumOperands
78125
78126         int numDstRegOperands() override { return 1; }
78127         int numSrcRegOperands() override { return 3; }
78128
78129         int
78130         getOperandSize(int opIdx) override
78131         {
78132             switch (opIdx) {
78133               case 0: //vgpr_a
78134                 return 4;
78135               case 1: //sgpr_r
78136                 return 32;
78137               case 2: //sgpr_s
78138                 return 4;
78139               case 3: //vgpr_d
78140                 return 16;
78141               default:
78142                 fatal("op idx %i out of bounds\n", opIdx);
78143                 return -1;
78144             }
78145         } // getOperandSize
78146
78147         bool
78148         isSrcOperand(int opIdx) override
78149         {
78150             switch (opIdx) {
78151               case 0: //vgpr_a
78152                 return true;
78153               case 1: //sgpr_r
78154                 return true;
78155               case 2: //sgpr_s
78156                 return true;
78157               case 3: //vgpr_d
78158                 return false;
78159               default:
78160                 fatal("op idx %i out of bounds\n", opIdx);
78161                 return false;
78162             }
78163         } // isSrcOperand
78164
78165         bool
78166         isDstOperand(int opIdx) override
78167         {
78168             switch (opIdx) {
78169               case 0: //vgpr_a
78170                 return false;
78171               case 1: //sgpr_r
78172                 return false;
78173               case 2: //sgpr_s
78174                 return false;
78175               case 3: //vgpr_d
78176                 return true;
78177               default:
78178                 fatal("op idx %i out of bounds\n", opIdx);
78179                 return false;
78180             }
78181         } // isDstOperand
78182
78183         void execute(GPUDynInstPtr) override;
78184     }; // Inst_MIMG__IMAGE_GATHER4_C_B_O
78185
78186     class Inst_MIMG__IMAGE_GATHER4_C_B_CL_O : public Inst_MIMG
78187     {
78188       public:
78189         Inst_MIMG__IMAGE_GATHER4_C_B_CL_O(InFmt_MIMG*);
78190         ~Inst_MIMG__IMAGE_GATHER4_C_B_CL_O();
78191
78192         int
78193         getNumOperands() override
78194         {
78195             return numDstRegOperands() + numSrcRegOperands();
78196         } // getNumOperands
78197
78198         int numDstRegOperands() override { return 1; }
78199         int numSrcRegOperands() override { return 3; }
78200
78201         int
78202         getOperandSize(int opIdx) override
78203         {
78204             switch (opIdx) {
78205               case 0: //vgpr_a
78206                 return 4;
78207               case 1: //sgpr_r
78208                 return 32;
78209               case 2: //sgpr_s
78210                 return 4;
78211               case 3: //vgpr_d
78212                 return 16;
78213               default:
78214                 fatal("op idx %i out of bounds\n", opIdx);
78215                 return -1;
78216             }
78217         } // getOperandSize
78218
78219         bool
78220         isSrcOperand(int opIdx) override
78221         {
78222             switch (opIdx) {
78223               case 0: //vgpr_a
78224                 return true;
78225               case 1: //sgpr_r
78226                 return true;
78227               case 2: //sgpr_s
78228                 return true;
78229               case 3: //vgpr_d
78230                 return false;
78231               default:
78232                 fatal("op idx %i out of bounds\n", opIdx);
78233                 return false;
78234             }
78235         } // isSrcOperand
78236
78237         bool
78238         isDstOperand(int opIdx) override
78239         {
78240             switch (opIdx) {
78241               case 0: //vgpr_a
78242                 return false;
78243               case 1: //sgpr_r
78244                 return false;
78245               case 2: //sgpr_s
78246                 return false;
78247               case 3: //vgpr_d
78248                 return true;
78249               default:
78250                 fatal("op idx %i out of bounds\n", opIdx);
78251                 return false;
78252             }
78253         } // isDstOperand
78254
78255         void execute(GPUDynInstPtr) override;
78256     }; // Inst_MIMG__IMAGE_GATHER4_C_B_CL_O
78257
78258     class Inst_MIMG__IMAGE_GATHER4_C_LZ_O : public Inst_MIMG
78259     {
78260       public:
78261         Inst_MIMG__IMAGE_GATHER4_C_LZ_O(InFmt_MIMG*);
78262         ~Inst_MIMG__IMAGE_GATHER4_C_LZ_O();
78263
78264         int
78265         getNumOperands() override
78266         {
78267             return numDstRegOperands() + numSrcRegOperands();
78268         } // getNumOperands
78269
78270         int numDstRegOperands() override { return 1; }
78271         int numSrcRegOperands() override { return 3; }
78272
78273         int
78274         getOperandSize(int opIdx) override
78275         {
78276             switch (opIdx) {
78277               case 0: //vgpr_a
78278                 return 4;
78279               case 1: //sgpr_r
78280                 return 32;
78281               case 2: //sgpr_s
78282                 return 4;
78283               case 3: //vgpr_d
78284                 return 16;
78285               default:
78286                 fatal("op idx %i out of bounds\n", opIdx);
78287                 return -1;
78288             }
78289         } // getOperandSize
78290
78291         bool
78292         isSrcOperand(int opIdx) override
78293         {
78294             switch (opIdx) {
78295               case 0: //vgpr_a
78296                 return true;
78297               case 1: //sgpr_r
78298                 return true;
78299               case 2: //sgpr_s
78300                 return true;
78301               case 3: //vgpr_d
78302                 return false;
78303               default:
78304                 fatal("op idx %i out of bounds\n", opIdx);
78305                 return false;
78306             }
78307         } // isSrcOperand
78308
78309         bool
78310         isDstOperand(int opIdx) override
78311         {
78312             switch (opIdx) {
78313               case 0: //vgpr_a
78314                 return false;
78315               case 1: //sgpr_r
78316                 return false;
78317               case 2: //sgpr_s
78318                 return false;
78319               case 3: //vgpr_d
78320                 return true;
78321               default:
78322                 fatal("op idx %i out of bounds\n", opIdx);
78323                 return false;
78324             }
78325         } // isDstOperand
78326
78327         void execute(GPUDynInstPtr) override;
78328     }; // Inst_MIMG__IMAGE_GATHER4_C_LZ_O
78329
78330     class Inst_MIMG__IMAGE_GET_LOD : public Inst_MIMG
78331     {
78332       public:
78333         Inst_MIMG__IMAGE_GET_LOD(InFmt_MIMG*);
78334         ~Inst_MIMG__IMAGE_GET_LOD();
78335
78336         int
78337         getNumOperands() override
78338         {
78339             return numDstRegOperands() + numSrcRegOperands();
78340         } // getNumOperands
78341
78342         int numDstRegOperands() override { return 1; }
78343         int numSrcRegOperands() override { return 3; }
78344
78345         int
78346         getOperandSize(int opIdx) override
78347         {
78348             switch (opIdx) {
78349               case 0: //vgpr_a
78350                 return 4;
78351               case 1: //sgpr_r
78352                 return 32;
78353               case 2: //sgpr_s
78354                 return 4;
78355               case 3: //vgpr_d
78356                 return 16;
78357               default:
78358                 fatal("op idx %i out of bounds\n", opIdx);
78359                 return -1;
78360             }
78361         } // getOperandSize
78362
78363         bool
78364         isSrcOperand(int opIdx) override
78365         {
78366             switch (opIdx) {
78367               case 0: //vgpr_a
78368                 return true;
78369               case 1: //sgpr_r
78370                 return true;
78371               case 2: //sgpr_s
78372                 return true;
78373               case 3: //vgpr_d
78374                 return false;
78375               default:
78376                 fatal("op idx %i out of bounds\n", opIdx);
78377                 return false;
78378             }
78379         } // isSrcOperand
78380
78381         bool
78382         isDstOperand(int opIdx) override
78383         {
78384             switch (opIdx) {
78385               case 0: //vgpr_a
78386                 return false;
78387               case 1: //sgpr_r
78388                 return false;
78389               case 2: //sgpr_s
78390                 return false;
78391               case 3: //vgpr_d
78392                 return true;
78393               default:
78394                 fatal("op idx %i out of bounds\n", opIdx);
78395                 return false;
78396             }
78397         } // isDstOperand
78398
78399         void execute(GPUDynInstPtr) override;
78400     }; // Inst_MIMG__IMAGE_GET_LOD
78401
78402     class Inst_MIMG__IMAGE_SAMPLE_CD : public Inst_MIMG
78403     {
78404       public:
78405         Inst_MIMG__IMAGE_SAMPLE_CD(InFmt_MIMG*);
78406         ~Inst_MIMG__IMAGE_SAMPLE_CD();
78407
78408         int
78409         getNumOperands() override
78410         {
78411             return numDstRegOperands() + numSrcRegOperands();
78412         } // getNumOperands
78413
78414         int numDstRegOperands() override { return 1; }
78415         int numSrcRegOperands() override { return 3; }
78416
78417         int
78418         getOperandSize(int opIdx) override
78419         {
78420             switch (opIdx) {
78421               case 0: //vgpr_a
78422                 return 4;
78423               case 1: //sgpr_r
78424                 return 32;
78425               case 2: //sgpr_s
78426                 return 4;
78427               case 3: //vgpr_d
78428                 return 16;
78429               default:
78430                 fatal("op idx %i out of bounds\n", opIdx);
78431                 return -1;
78432             }
78433         } // getOperandSize
78434
78435         bool
78436         isSrcOperand(int opIdx) override
78437         {
78438             switch (opIdx) {
78439               case 0: //vgpr_a
78440                 return true;
78441               case 1: //sgpr_r
78442                 return true;
78443               case 2: //sgpr_s
78444                 return true;
78445               case 3: //vgpr_d
78446                 return false;
78447               default:
78448                 fatal("op idx %i out of bounds\n", opIdx);
78449                 return false;
78450             }
78451         } // isSrcOperand
78452
78453         bool
78454         isDstOperand(int opIdx) override
78455         {
78456             switch (opIdx) {
78457               case 0: //vgpr_a
78458                 return false;
78459               case 1: //sgpr_r
78460                 return false;
78461               case 2: //sgpr_s
78462                 return false;
78463               case 3: //vgpr_d
78464                 return true;
78465               default:
78466                 fatal("op idx %i out of bounds\n", opIdx);
78467                 return false;
78468             }
78469         } // isDstOperand
78470
78471         void execute(GPUDynInstPtr) override;
78472     }; // Inst_MIMG__IMAGE_SAMPLE_CD
78473
78474     class Inst_MIMG__IMAGE_SAMPLE_CD_CL : public Inst_MIMG
78475     {
78476       public:
78477         Inst_MIMG__IMAGE_SAMPLE_CD_CL(InFmt_MIMG*);
78478         ~Inst_MIMG__IMAGE_SAMPLE_CD_CL();
78479
78480         int
78481         getNumOperands() override
78482         {
78483             return numDstRegOperands() + numSrcRegOperands();
78484         } // getNumOperands
78485
78486         int numDstRegOperands() override { return 1; }
78487         int numSrcRegOperands() override { return 3; }
78488
78489         int
78490         getOperandSize(int opIdx) override
78491         {
78492             switch (opIdx) {
78493               case 0: //vgpr_a
78494                 return 4;
78495               case 1: //sgpr_r
78496                 return 32;
78497               case 2: //sgpr_s
78498                 return 4;
78499               case 3: //vgpr_d
78500                 return 16;
78501               default:
78502                 fatal("op idx %i out of bounds\n", opIdx);
78503                 return -1;
78504             }
78505         } // getOperandSize
78506
78507         bool
78508         isSrcOperand(int opIdx) override
78509         {
78510             switch (opIdx) {
78511               case 0: //vgpr_a
78512                 return true;
78513               case 1: //sgpr_r
78514                 return true;
78515               case 2: //sgpr_s
78516                 return true;
78517               case 3: //vgpr_d
78518                 return false;
78519               default:
78520                 fatal("op idx %i out of bounds\n", opIdx);
78521                 return false;
78522             }
78523         } // isSrcOperand
78524
78525         bool
78526         isDstOperand(int opIdx) override
78527         {
78528             switch (opIdx) {
78529               case 0: //vgpr_a
78530                 return false;
78531               case 1: //sgpr_r
78532                 return false;
78533               case 2: //sgpr_s
78534                 return false;
78535               case 3: //vgpr_d
78536                 return true;
78537               default:
78538                 fatal("op idx %i out of bounds\n", opIdx);
78539                 return false;
78540             }
78541         } // isDstOperand
78542
78543         void execute(GPUDynInstPtr) override;
78544     }; // Inst_MIMG__IMAGE_SAMPLE_CD_CL
78545
78546     class Inst_MIMG__IMAGE_SAMPLE_C_CD : public Inst_MIMG
78547     {
78548       public:
78549         Inst_MIMG__IMAGE_SAMPLE_C_CD(InFmt_MIMG*);
78550         ~Inst_MIMG__IMAGE_SAMPLE_C_CD();
78551
78552         int
78553         getNumOperands() override
78554         {
78555             return numDstRegOperands() + numSrcRegOperands();
78556         } // getNumOperands
78557
78558         int numDstRegOperands() override { return 1; }
78559         int numSrcRegOperands() override { return 3; }
78560
78561         int
78562         getOperandSize(int opIdx) override
78563         {
78564             switch (opIdx) {
78565               case 0: //vgpr_a
78566                 return 4;
78567               case 1: //sgpr_r
78568                 return 32;
78569               case 2: //sgpr_s
78570                 return 4;
78571               case 3: //vgpr_d
78572                 return 16;
78573               default:
78574                 fatal("op idx %i out of bounds\n", opIdx);
78575                 return -1;
78576             }
78577         } // getOperandSize
78578
78579         bool
78580         isSrcOperand(int opIdx) override
78581         {
78582             switch (opIdx) {
78583               case 0: //vgpr_a
78584                 return true;
78585               case 1: //sgpr_r
78586                 return true;
78587               case 2: //sgpr_s
78588                 return true;
78589               case 3: //vgpr_d
78590                 return false;
78591               default:
78592                 fatal("op idx %i out of bounds\n", opIdx);
78593                 return false;
78594             }
78595         } // isSrcOperand
78596
78597         bool
78598         isDstOperand(int opIdx) override
78599         {
78600             switch (opIdx) {
78601               case 0: //vgpr_a
78602                 return false;
78603               case 1: //sgpr_r
78604                 return false;
78605               case 2: //sgpr_s
78606                 return false;
78607               case 3: //vgpr_d
78608                 return true;
78609               default:
78610                 fatal("op idx %i out of bounds\n", opIdx);
78611                 return false;
78612             }
78613         } // isDstOperand
78614
78615         void execute(GPUDynInstPtr) override;
78616     }; // Inst_MIMG__IMAGE_SAMPLE_C_CD
78617
78618     class Inst_MIMG__IMAGE_SAMPLE_C_CD_CL : public Inst_MIMG
78619     {
78620       public:
78621         Inst_MIMG__IMAGE_SAMPLE_C_CD_CL(InFmt_MIMG*);
78622         ~Inst_MIMG__IMAGE_SAMPLE_C_CD_CL();
78623
78624         int
78625         getNumOperands() override
78626         {
78627             return numDstRegOperands() + numSrcRegOperands();
78628         } // getNumOperands
78629
78630         int numDstRegOperands() override { return 1; }
78631         int numSrcRegOperands() override { return 3; }
78632
78633         int
78634         getOperandSize(int opIdx) override
78635         {
78636             switch (opIdx) {
78637               case 0: //vgpr_a
78638                 return 4;
78639               case 1: //sgpr_r
78640                 return 32;
78641               case 2: //sgpr_s
78642                 return 4;
78643               case 3: //vgpr_d
78644                 return 16;
78645               default:
78646                 fatal("op idx %i out of bounds\n", opIdx);
78647                 return -1;
78648             }
78649         } // getOperandSize
78650
78651         bool
78652         isSrcOperand(int opIdx) override
78653         {
78654             switch (opIdx) {
78655               case 0: //vgpr_a
78656                 return true;
78657               case 1: //sgpr_r
78658                 return true;
78659               case 2: //sgpr_s
78660                 return true;
78661               case 3: //vgpr_d
78662                 return false;
78663               default:
78664                 fatal("op idx %i out of bounds\n", opIdx);
78665                 return false;
78666             }
78667         } // isSrcOperand
78668
78669         bool
78670         isDstOperand(int opIdx) override
78671         {
78672             switch (opIdx) {
78673               case 0: //vgpr_a
78674                 return false;
78675               case 1: //sgpr_r
78676                 return false;
78677               case 2: //sgpr_s
78678                 return false;
78679               case 3: //vgpr_d
78680                 return true;
78681               default:
78682                 fatal("op idx %i out of bounds\n", opIdx);
78683                 return false;
78684             }
78685         } // isDstOperand
78686
78687         void execute(GPUDynInstPtr) override;
78688     }; // Inst_MIMG__IMAGE_SAMPLE_C_CD_CL
78689
78690     class Inst_MIMG__IMAGE_SAMPLE_CD_O : public Inst_MIMG
78691     {
78692       public:
78693         Inst_MIMG__IMAGE_SAMPLE_CD_O(InFmt_MIMG*);
78694         ~Inst_MIMG__IMAGE_SAMPLE_CD_O();
78695
78696         int
78697         getNumOperands() override
78698         {
78699             return numDstRegOperands() + numSrcRegOperands();
78700         } // getNumOperands
78701
78702         int numDstRegOperands() override { return 1; }
78703         int numSrcRegOperands() override { return 3; }
78704
78705         int
78706         getOperandSize(int opIdx) override
78707         {
78708             switch (opIdx) {
78709               case 0: //vgpr_a
78710                 return 4;
78711               case 1: //sgpr_r
78712                 return 32;
78713               case 2: //sgpr_s
78714                 return 4;
78715               case 3: //vgpr_d
78716                 return 16;
78717               default:
78718                 fatal("op idx %i out of bounds\n", opIdx);
78719                 return -1;
78720             }
78721         } // getOperandSize
78722
78723         bool
78724         isSrcOperand(int opIdx) override
78725         {
78726             switch (opIdx) {
78727               case 0: //vgpr_a
78728                 return true;
78729               case 1: //sgpr_r
78730                 return true;
78731               case 2: //sgpr_s
78732                 return true;
78733               case 3: //vgpr_d
78734                 return false;
78735               default:
78736                 fatal("op idx %i out of bounds\n", opIdx);
78737                 return false;
78738             }
78739         } // isSrcOperand
78740
78741         bool
78742         isDstOperand(int opIdx) override
78743         {
78744             switch (opIdx) {
78745               case 0: //vgpr_a
78746                 return false;
78747               case 1: //sgpr_r
78748                 return false;
78749               case 2: //sgpr_s
78750                 return false;
78751               case 3: //vgpr_d
78752                 return true;
78753               default:
78754                 fatal("op idx %i out of bounds\n", opIdx);
78755                 return false;
78756             }
78757         } // isDstOperand
78758
78759         void execute(GPUDynInstPtr) override;
78760     }; // Inst_MIMG__IMAGE_SAMPLE_CD_O
78761
78762     class Inst_MIMG__IMAGE_SAMPLE_CD_CL_O : public Inst_MIMG
78763     {
78764       public:
78765         Inst_MIMG__IMAGE_SAMPLE_CD_CL_O(InFmt_MIMG*);
78766         ~Inst_MIMG__IMAGE_SAMPLE_CD_CL_O();
78767
78768         int
78769         getNumOperands() override
78770         {
78771             return numDstRegOperands() + numSrcRegOperands();
78772         } // getNumOperands
78773
78774         int numDstRegOperands() override { return 1; }
78775         int numSrcRegOperands() override { return 3; }
78776
78777         int
78778         getOperandSize(int opIdx) override
78779         {
78780             switch (opIdx) {
78781               case 0: //vgpr_a
78782                 return 4;
78783               case 1: //sgpr_r
78784                 return 32;
78785               case 2: //sgpr_s
78786                 return 4;
78787               case 3: //vgpr_d
78788                 return 16;
78789               default:
78790                 fatal("op idx %i out of bounds\n", opIdx);
78791                 return -1;
78792             }
78793         } // getOperandSize
78794
78795         bool
78796         isSrcOperand(int opIdx) override
78797         {
78798             switch (opIdx) {
78799               case 0: //vgpr_a
78800                 return true;
78801               case 1: //sgpr_r
78802                 return true;
78803               case 2: //sgpr_s
78804                 return true;
78805               case 3: //vgpr_d
78806                 return false;
78807               default:
78808                 fatal("op idx %i out of bounds\n", opIdx);
78809                 return false;
78810             }
78811         } // isSrcOperand
78812
78813         bool
78814         isDstOperand(int opIdx) override
78815         {
78816             switch (opIdx) {
78817               case 0: //vgpr_a
78818                 return false;
78819               case 1: //sgpr_r
78820                 return false;
78821               case 2: //sgpr_s
78822                 return false;
78823               case 3: //vgpr_d
78824                 return true;
78825               default:
78826                 fatal("op idx %i out of bounds\n", opIdx);
78827                 return false;
78828             }
78829         } // isDstOperand
78830
78831         void execute(GPUDynInstPtr) override;
78832     }; // Inst_MIMG__IMAGE_SAMPLE_CD_CL_O
78833
78834     class Inst_MIMG__IMAGE_SAMPLE_C_CD_O : public Inst_MIMG
78835     {
78836       public:
78837         Inst_MIMG__IMAGE_SAMPLE_C_CD_O(InFmt_MIMG*);
78838         ~Inst_MIMG__IMAGE_SAMPLE_C_CD_O();
78839
78840         int
78841         getNumOperands() override
78842         {
78843             return numDstRegOperands() + numSrcRegOperands();
78844         } // getNumOperands
78845
78846         int numDstRegOperands() override { return 1; }
78847         int numSrcRegOperands() override { return 3; }
78848
78849         int
78850         getOperandSize(int opIdx) override
78851         {
78852             switch (opIdx) {
78853               case 0: //vgpr_a
78854                 return 4;
78855               case 1: //sgpr_r
78856                 return 32;
78857               case 2: //sgpr_s
78858                 return 4;
78859               case 3: //vgpr_d
78860                 return 16;
78861               default:
78862                 fatal("op idx %i out of bounds\n", opIdx);
78863                 return -1;
78864             }
78865         } // getOperandSize
78866
78867         bool
78868         isSrcOperand(int opIdx) override
78869         {
78870             switch (opIdx) {
78871               case 0: //vgpr_a
78872                 return true;
78873               case 1: //sgpr_r
78874                 return true;
78875               case 2: //sgpr_s
78876                 return true;
78877               case 3: //vgpr_d
78878                 return false;
78879               default:
78880                 fatal("op idx %i out of bounds\n", opIdx);
78881                 return false;
78882             }
78883         } // isSrcOperand
78884
78885         bool
78886         isDstOperand(int opIdx) override
78887         {
78888             switch (opIdx) {
78889               case 0: //vgpr_a
78890                 return false;
78891               case 1: //sgpr_r
78892                 return false;
78893               case 2: //sgpr_s
78894                 return false;
78895               case 3: //vgpr_d
78896                 return true;
78897               default:
78898                 fatal("op idx %i out of bounds\n", opIdx);
78899                 return false;
78900             }
78901         } // isDstOperand
78902
78903         void execute(GPUDynInstPtr) override;
78904     }; // Inst_MIMG__IMAGE_SAMPLE_C_CD_O
78905
78906     class Inst_MIMG__IMAGE_SAMPLE_C_CD_CL_O : public Inst_MIMG
78907     {
78908       public:
78909         Inst_MIMG__IMAGE_SAMPLE_C_CD_CL_O(InFmt_MIMG*);
78910         ~Inst_MIMG__IMAGE_SAMPLE_C_CD_CL_O();
78911
78912         int
78913         getNumOperands() override
78914         {
78915             return numDstRegOperands() + numSrcRegOperands();
78916         } // getNumOperands
78917
78918         int numDstRegOperands() override { return 1; }
78919         int numSrcRegOperands() override { return 3; }
78920
78921         int
78922         getOperandSize(int opIdx) override
78923         {
78924             switch (opIdx) {
78925               case 0: //vgpr_a
78926                 return 4;
78927               case 1: //sgpr_r
78928                 return 32;
78929               case 2: //sgpr_s
78930                 return 4;
78931               case 3: //vgpr_d
78932                 return 16;
78933               default:
78934                 fatal("op idx %i out of bounds\n", opIdx);
78935                 return -1;
78936             }
78937         } // getOperandSize
78938
78939         bool
78940         isSrcOperand(int opIdx) override
78941         {
78942             switch (opIdx) {
78943               case 0: //vgpr_a
78944                 return true;
78945               case 1: //sgpr_r
78946                 return true;
78947               case 2: //sgpr_s
78948                 return true;
78949               case 3: //vgpr_d
78950                 return false;
78951               default:
78952                 fatal("op idx %i out of bounds\n", opIdx);
78953                 return false;
78954             }
78955         } // isSrcOperand
78956
78957         bool
78958         isDstOperand(int opIdx) override
78959         {
78960             switch (opIdx) {
78961               case 0: //vgpr_a
78962                 return false;
78963               case 1: //sgpr_r
78964                 return false;
78965               case 2: //sgpr_s
78966                 return false;
78967               case 3: //vgpr_d
78968                 return true;
78969               default:
78970                 fatal("op idx %i out of bounds\n", opIdx);
78971                 return false;
78972             }
78973         } // isDstOperand
78974
78975         void execute(GPUDynInstPtr) override;
78976     }; // Inst_MIMG__IMAGE_SAMPLE_C_CD_CL_O
78977
78978     class Inst_EXP__EXP : public Inst_EXP
78979     {
78980       public:
78981         Inst_EXP__EXP(InFmt_EXP*);
78982         ~Inst_EXP__EXP();
78983
78984         int
78985         getNumOperands() override
78986         {
78987             return numDstRegOperands() + numSrcRegOperands();
78988         } // getNumOperands
78989
78990         int numDstRegOperands() override { return 1; }
78991         int numSrcRegOperands() override { return 4; }
78992
78993         int
78994         getOperandSize(int opIdx) override
78995         {
78996             switch (opIdx) {
78997               case 0: //
78998                 return 32;
78999               case 1: //
79000                 return 32;
79001               case 2: //
79002                 return 32;
79003               case 3: //
79004                 return 32;
79005               case 4: //
79006                 return 32;
79007               default:
79008                 fatal("op idx %i out of bounds\n", opIdx);
79009                 return -1;
79010             }
79011         } // getOperandSize
79012
79013         bool
79014         isSrcOperand(int opIdx) override
79015         {
79016             switch (opIdx) {
79017               case 0: //
79018                 return true;
79019               case 1: //
79020                 return true;
79021               case 2: //
79022                 return true;
79023               case 3: //
79024                 return true;
79025               case 4: //
79026                 return false;
79027               default:
79028                 fatal("op idx %i out of bounds\n", opIdx);
79029                 return false;
79030             }
79031         } // isSrcOperand
79032
79033         bool
79034         isDstOperand(int opIdx) override
79035         {
79036             switch (opIdx) {
79037               case 0: //
79038                 return false;
79039               case 1: //
79040                 return false;
79041               case 2: //
79042                 return false;
79043               case 3: //
79044                 return false;
79045               case 4: //
79046                 return true;
79047               default:
79048                 fatal("op idx %i out of bounds\n", opIdx);
79049                 return false;
79050             }
79051         } // isDstOperand
79052
79053         void execute(GPUDynInstPtr) override;
79054     }; // Inst_EXP__EXP
79055
79056     class Inst_FLAT__FLAT_LOAD_UBYTE : public Inst_FLAT
79057     {
79058       public:
79059         Inst_FLAT__FLAT_LOAD_UBYTE(InFmt_FLAT*);
79060         ~Inst_FLAT__FLAT_LOAD_UBYTE();
79061
79062         int
79063         getNumOperands() override
79064         {
79065             return numDstRegOperands() + numSrcRegOperands();
79066         } // getNumOperands
79067
79068         int numDstRegOperands() override { return 1; }
79069         int numSrcRegOperands() override { return 1; }
79070
79071         int
79072         getOperandSize(int opIdx) override
79073         {
79074             switch (opIdx) {
79075               case 0: //vgpr_addr
79076                 return 8;
79077               case 1: //vgpr_dst
79078                 return 1;
79079               default:
79080                 fatal("op idx %i out of bounds\n", opIdx);
79081                 return -1;
79082             }
79083         } // getOperandSize
79084
79085         bool
79086         isSrcOperand(int opIdx) override
79087         {
79088             switch (opIdx) {
79089               case 0: //vgpr_addr
79090                 return true;
79091               case 1: //vgpr_dst
79092                 return false;
79093               default:
79094                 fatal("op idx %i out of bounds\n", opIdx);
79095                 return false;
79096             }
79097         } // isSrcOperand
79098
79099         bool
79100         isDstOperand(int opIdx) override
79101         {
79102             switch (opIdx) {
79103               case 0: //vgpr_addr
79104                 return false;
79105               case 1: //vgpr_dst
79106                 return true;
79107               default:
79108                 fatal("op idx %i out of bounds\n", opIdx);
79109                 return false;
79110             }
79111         } // isDstOperand
79112
79113         void execute(GPUDynInstPtr) override;
79114         void initiateAcc(GPUDynInstPtr) override;
79115         void completeAcc(GPUDynInstPtr) override;
79116     }; // Inst_FLAT__FLAT_LOAD_UBYTE
79117
79118     class Inst_FLAT__FLAT_LOAD_SBYTE : public Inst_FLAT
79119     {
79120       public:
79121         Inst_FLAT__FLAT_LOAD_SBYTE(InFmt_FLAT*);
79122         ~Inst_FLAT__FLAT_LOAD_SBYTE();
79123
79124         int
79125         getNumOperands() override
79126         {
79127             return numDstRegOperands() + numSrcRegOperands();
79128         } // getNumOperands
79129
79130         int numDstRegOperands() override { return 1; }
79131         int numSrcRegOperands() override { return 1; }
79132
79133         int
79134         getOperandSize(int opIdx) override
79135         {
79136             switch (opIdx) {
79137               case 0: //vgpr_addr
79138                 return 8;
79139               case 1: //vgpr_dst
79140                 return 32;
79141               default:
79142                 fatal("op idx %i out of bounds\n", opIdx);
79143                 return -1;
79144             }
79145         } // getOperandSize
79146
79147         bool
79148         isSrcOperand(int opIdx) override
79149         {
79150             switch (opIdx) {
79151               case 0: //vgpr_addr
79152                 return true;
79153               case 1: //vgpr_dst
79154                 return false;
79155               default:
79156                 fatal("op idx %i out of bounds\n", opIdx);
79157                 return false;
79158             }
79159         } // isSrcOperand
79160
79161         bool
79162         isDstOperand(int opIdx) override
79163         {
79164             switch (opIdx) {
79165               case 0: //vgpr_addr
79166                 return false;
79167               case 1: //vgpr_dst
79168                 return true;
79169               default:
79170                 fatal("op idx %i out of bounds\n", opIdx);
79171                 return false;
79172             }
79173         } // isDstOperand
79174
79175         void execute(GPUDynInstPtr) override;
79176         void initiateAcc(GPUDynInstPtr) override;
79177         void completeAcc(GPUDynInstPtr) override;
79178     }; // Inst_FLAT__FLAT_LOAD_SBYTE
79179
79180     class Inst_FLAT__FLAT_LOAD_USHORT : public Inst_FLAT
79181     {
79182       public:
79183         Inst_FLAT__FLAT_LOAD_USHORT(InFmt_FLAT*);
79184         ~Inst_FLAT__FLAT_LOAD_USHORT();
79185
79186         int
79187         getNumOperands() override
79188         {
79189             return numDstRegOperands() + numSrcRegOperands();
79190         } // getNumOperands
79191
79192         int numDstRegOperands() override { return 1; }
79193         int numSrcRegOperands() override { return 1; }
79194
79195         int
79196         getOperandSize(int opIdx) override
79197         {
79198             switch (opIdx) {
79199               case 0: //vgpr_addr
79200                 return 8;
79201               case 1: //vgpr_dst
79202                 return 2;
79203               default:
79204                 fatal("op idx %i out of bounds\n", opIdx);
79205                 return -1;
79206             }
79207         } // getOperandSize
79208
79209         bool
79210         isSrcOperand(int opIdx) override
79211         {
79212             switch (opIdx) {
79213               case 0: //vgpr_addr
79214                 return true;
79215               case 1: //vgpr_dst
79216                 return false;
79217               default:
79218                 fatal("op idx %i out of bounds\n", opIdx);
79219                 return false;
79220             }
79221         } // isSrcOperand
79222
79223         bool
79224         isDstOperand(int opIdx) override
79225         {
79226             switch (opIdx) {
79227               case 0: //vgpr_addr
79228                 return false;
79229               case 1: //vgpr_dst
79230                 return true;
79231               default:
79232                 fatal("op idx %i out of bounds\n", opIdx);
79233                 return false;
79234             }
79235         } // isDstOperand
79236
79237         void execute(GPUDynInstPtr) override;
79238         void initiateAcc(GPUDynInstPtr) override;
79239         void completeAcc(GPUDynInstPtr) override;
79240     }; // Inst_FLAT__FLAT_LOAD_USHORT
79241
79242     class Inst_FLAT__FLAT_LOAD_SSHORT : public Inst_FLAT
79243     {
79244       public:
79245         Inst_FLAT__FLAT_LOAD_SSHORT(InFmt_FLAT*);
79246         ~Inst_FLAT__FLAT_LOAD_SSHORT();
79247
79248         int
79249         getNumOperands() override
79250         {
79251             return numDstRegOperands() + numSrcRegOperands();
79252         } // getNumOperands
79253
79254         int numDstRegOperands() override { return 1; }
79255         int numSrcRegOperands() override { return 1; }
79256
79257         int
79258         getOperandSize(int opIdx) override
79259         {
79260             switch (opIdx) {
79261               case 0: //vgpr_addr
79262                 return 8;
79263               case 1: //vgpr_dst
79264                 return 32;
79265               default:
79266                 fatal("op idx %i out of bounds\n", opIdx);
79267                 return -1;
79268             }
79269         } // getOperandSize
79270
79271         bool
79272         isSrcOperand(int opIdx) override
79273         {
79274             switch (opIdx) {
79275               case 0: //vgpr_addr
79276                 return true;
79277               case 1: //vgpr_dst
79278                 return false;
79279               default:
79280                 fatal("op idx %i out of bounds\n", opIdx);
79281                 return false;
79282             }
79283         } // isSrcOperand
79284
79285         bool
79286         isDstOperand(int opIdx) override
79287         {
79288             switch (opIdx) {
79289               case 0: //vgpr_addr
79290                 return false;
79291               case 1: //vgpr_dst
79292                 return true;
79293               default:
79294                 fatal("op idx %i out of bounds\n", opIdx);
79295                 return false;
79296             }
79297         } // isDstOperand
79298
79299         void execute(GPUDynInstPtr) override;
79300         void initiateAcc(GPUDynInstPtr) override;
79301         void completeAcc(GPUDynInstPtr) override;
79302     }; // Inst_FLAT__FLAT_LOAD_SSHORT
79303
79304     class Inst_FLAT__FLAT_LOAD_DWORD : public Inst_FLAT
79305     {
79306       public:
79307         Inst_FLAT__FLAT_LOAD_DWORD(InFmt_FLAT*);
79308         ~Inst_FLAT__FLAT_LOAD_DWORD();
79309
79310         int
79311         getNumOperands() override
79312         {
79313             return numDstRegOperands() + numSrcRegOperands();
79314         } // getNumOperands
79315
79316         int numDstRegOperands() override { return 1; }
79317         int numSrcRegOperands() override { return 1; }
79318
79319         int
79320         getOperandSize(int opIdx) override
79321         {
79322             switch (opIdx) {
79323               case 0: //vgpr_addr
79324                 return 8;
79325               case 1: //vgpr_dst
79326                 return 4;
79327               default:
79328                 fatal("op idx %i out of bounds\n", opIdx);
79329                 return -1;
79330             }
79331         } // getOperandSize
79332
79333         bool
79334         isSrcOperand(int opIdx) override
79335         {
79336             switch (opIdx) {
79337               case 0: //vgpr_addr
79338                 return true;
79339               case 1: //vgpr_dst
79340                 return false;
79341               default:
79342                 fatal("op idx %i out of bounds\n", opIdx);
79343                 return false;
79344             }
79345         } // isSrcOperand
79346
79347         bool
79348         isDstOperand(int opIdx) override
79349         {
79350             switch (opIdx) {
79351               case 0: //vgpr_addr
79352                 return false;
79353               case 1: //vgpr_dst
79354                 return true;
79355               default:
79356                 fatal("op idx %i out of bounds\n", opIdx);
79357                 return false;
79358             }
79359         } // isDstOperand
79360
79361         void execute(GPUDynInstPtr) override;
79362         void initiateAcc(GPUDynInstPtr) override;
79363         void completeAcc(GPUDynInstPtr) override;
79364     }; // Inst_FLAT__FLAT_LOAD_DWORD
79365
79366     class Inst_FLAT__FLAT_LOAD_DWORDX2 : public Inst_FLAT
79367     {
79368       public:
79369         Inst_FLAT__FLAT_LOAD_DWORDX2(InFmt_FLAT*);
79370         ~Inst_FLAT__FLAT_LOAD_DWORDX2();
79371
79372         int
79373         getNumOperands() override
79374         {
79375             return numDstRegOperands() + numSrcRegOperands();
79376         } // getNumOperands
79377
79378         int numDstRegOperands() override { return 1; }
79379         int numSrcRegOperands() override { return 1; }
79380
79381         int
79382         getOperandSize(int opIdx) override
79383         {
79384             switch (opIdx) {
79385               case 0: //vgpr_addr
79386                 return 8;
79387               case 1: //vgpr_dst
79388                 return 8;
79389               default:
79390                 fatal("op idx %i out of bounds\n", opIdx);
79391                 return -1;
79392             }
79393         } // getOperandSize
79394
79395         bool
79396         isSrcOperand(int opIdx) override
79397         {
79398             switch (opIdx) {
79399               case 0: //vgpr_addr
79400                 return true;
79401               case 1: //vgpr_dst
79402                 return false;
79403               default:
79404                 fatal("op idx %i out of bounds\n", opIdx);
79405                 return false;
79406             }
79407         } // isSrcOperand
79408
79409         bool
79410         isDstOperand(int opIdx) override
79411         {
79412             switch (opIdx) {
79413               case 0: //vgpr_addr
79414                 return false;
79415               case 1: //vgpr_dst
79416                 return true;
79417               default:
79418                 fatal("op idx %i out of bounds\n", opIdx);
79419                 return false;
79420             }
79421         } // isDstOperand
79422
79423         void execute(GPUDynInstPtr) override;
79424         void initiateAcc(GPUDynInstPtr) override;
79425         void completeAcc(GPUDynInstPtr) override;
79426     }; // Inst_FLAT__FLAT_LOAD_DWORDX2
79427
79428     class Inst_FLAT__FLAT_LOAD_DWORDX3 : public Inst_FLAT
79429     {
79430       public:
79431         Inst_FLAT__FLAT_LOAD_DWORDX3(InFmt_FLAT*);
79432         ~Inst_FLAT__FLAT_LOAD_DWORDX3();
79433
79434         int
79435         getNumOperands() override
79436         {
79437             return numDstRegOperands() + numSrcRegOperands();
79438         } // getNumOperands
79439
79440         int numDstRegOperands() override { return 1; }
79441         int numSrcRegOperands() override { return 1; }
79442
79443         int
79444         getOperandSize(int opIdx) override
79445         {
79446             switch (opIdx) {
79447               case 0: //vgpr_addr
79448                 return 8;
79449               case 1: //vgpr_dst
79450                 return 12;
79451               default:
79452                 fatal("op idx %i out of bounds\n", opIdx);
79453                 return -1;
79454             }
79455         } // getOperandSize
79456
79457         bool
79458         isSrcOperand(int opIdx) override
79459         {
79460             switch (opIdx) {
79461               case 0: //vgpr_addr
79462                 return true;
79463               case 1: //vgpr_dst
79464                 return false;
79465               default:
79466                 fatal("op idx %i out of bounds\n", opIdx);
79467                 return false;
79468             }
79469         } // isSrcOperand
79470
79471         bool
79472         isDstOperand(int opIdx) override
79473         {
79474             switch (opIdx) {
79475               case 0: //vgpr_addr
79476                 return false;
79477               case 1: //vgpr_dst
79478                 return true;
79479               default:
79480                 fatal("op idx %i out of bounds\n", opIdx);
79481                 return false;
79482             }
79483         } // isDstOperand
79484
79485         void execute(GPUDynInstPtr) override;
79486         void initiateAcc(GPUDynInstPtr) override;
79487         void completeAcc(GPUDynInstPtr) override;
79488     }; // Inst_FLAT__FLAT_LOAD_DWORDX3
79489
79490     class Inst_FLAT__FLAT_LOAD_DWORDX4 : public Inst_FLAT
79491     {
79492       public:
79493         Inst_FLAT__FLAT_LOAD_DWORDX4(InFmt_FLAT*);
79494         ~Inst_FLAT__FLAT_LOAD_DWORDX4();
79495
79496         int
79497         getNumOperands() override
79498         {
79499             return numDstRegOperands() + numSrcRegOperands();
79500         } // getNumOperands
79501
79502         int numDstRegOperands() override { return 1; }
79503         int numSrcRegOperands() override { return 1; }
79504
79505         int
79506         getOperandSize(int opIdx) override
79507         {
79508             switch (opIdx) {
79509               case 0: //vgpr_addr
79510                 return 8;
79511               case 1: //vgpr_dst
79512                 return 16;
79513               default:
79514                 fatal("op idx %i out of bounds\n", opIdx);
79515                 return -1;
79516             }
79517         } // getOperandSize
79518
79519         bool
79520         isSrcOperand(int opIdx) override
79521         {
79522             switch (opIdx) {
79523               case 0: //vgpr_addr
79524                 return true;
79525               case 1: //vgpr_dst
79526                 return false;
79527               default:
79528                 fatal("op idx %i out of bounds\n", opIdx);
79529                 return false;
79530             }
79531         } // isSrcOperand
79532
79533         bool
79534         isDstOperand(int opIdx) override
79535         {
79536             switch (opIdx) {
79537               case 0: //vgpr_addr
79538                 return false;
79539               case 1: //vgpr_dst
79540                 return true;
79541               default:
79542                 fatal("op idx %i out of bounds\n", opIdx);
79543                 return false;
79544             }
79545         } // isDstOperand
79546
79547         void execute(GPUDynInstPtr) override;
79548         void initiateAcc(GPUDynInstPtr) override;
79549         void completeAcc(GPUDynInstPtr) override;
79550     }; // Inst_FLAT__FLAT_LOAD_DWORDX4
79551
79552     class Inst_FLAT__FLAT_STORE_BYTE : public Inst_FLAT
79553     {
79554       public:
79555         Inst_FLAT__FLAT_STORE_BYTE(InFmt_FLAT*);
79556         ~Inst_FLAT__FLAT_STORE_BYTE();
79557
79558         int
79559         getNumOperands() override
79560         {
79561             return numDstRegOperands() + numSrcRegOperands();
79562         } // getNumOperands
79563
79564         int numDstRegOperands() override { return 0; }
79565         int numSrcRegOperands() override { return 2; }
79566
79567         int
79568         getOperandSize(int opIdx) override
79569         {
79570             switch (opIdx) {
79571               case 0: //vgpr_addr
79572                 return 8;
79573               case 1: //vgpr_src
79574                 return 1;
79575               default:
79576                 fatal("op idx %i out of bounds\n", opIdx);
79577                 return -1;
79578             }
79579         } // getOperandSize
79580
79581         bool
79582         isSrcOperand(int opIdx) override
79583         {
79584             switch (opIdx) {
79585               case 0: //vgpr_addr
79586                 return true;
79587               case 1: //vgpr_src
79588                 return true;
79589               default:
79590                 fatal("op idx %i out of bounds\n", opIdx);
79591                 return false;
79592             }
79593         } // isSrcOperand
79594
79595         bool
79596         isDstOperand(int opIdx) override
79597         {
79598             switch (opIdx) {
79599               case 0: //vgpr_addr
79600                 return false;
79601               case 1: //vgpr_src
79602                 return false;
79603               default:
79604                 fatal("op idx %i out of bounds\n", opIdx);
79605                 return false;
79606             }
79607         } // isDstOperand
79608
79609         void execute(GPUDynInstPtr) override;
79610         void initiateAcc(GPUDynInstPtr) override;
79611         void completeAcc(GPUDynInstPtr) override;
79612     }; // Inst_FLAT__FLAT_STORE_BYTE
79613
79614     class Inst_FLAT__FLAT_STORE_SHORT : public Inst_FLAT
79615     {
79616       public:
79617         Inst_FLAT__FLAT_STORE_SHORT(InFmt_FLAT*);
79618         ~Inst_FLAT__FLAT_STORE_SHORT();
79619
79620         int
79621         getNumOperands() override
79622         {
79623             return numDstRegOperands() + numSrcRegOperands();
79624         } // getNumOperands
79625
79626         int numDstRegOperands() override { return 0; }
79627         int numSrcRegOperands() override { return 2; }
79628
79629         int
79630         getOperandSize(int opIdx) override
79631         {
79632             switch (opIdx) {
79633               case 0: //vgpr_addr
79634                 return 8;
79635               case 1: //vgpr_src
79636                 return 2;
79637               default:
79638                 fatal("op idx %i out of bounds\n", opIdx);
79639                 return -1;
79640             }
79641         } // getOperandSize
79642
79643         bool
79644         isSrcOperand(int opIdx) override
79645         {
79646             switch (opIdx) {
79647               case 0: //vgpr_addr
79648                 return true;
79649               case 1: //vgpr_src
79650                 return true;
79651               default:
79652                 fatal("op idx %i out of bounds\n", opIdx);
79653                 return false;
79654             }
79655         } // isSrcOperand
79656
79657         bool
79658         isDstOperand(int opIdx) override
79659         {
79660             switch (opIdx) {
79661               case 0: //vgpr_addr
79662                 return false;
79663               case 1: //vgpr_src
79664                 return false;
79665               default:
79666                 fatal("op idx %i out of bounds\n", opIdx);
79667                 return false;
79668             }
79669         } // isDstOperand
79670
79671         void execute(GPUDynInstPtr) override;
79672         void initiateAcc(GPUDynInstPtr) override;
79673         void completeAcc(GPUDynInstPtr) override;
79674     }; // Inst_FLAT__FLAT_STORE_SHORT
79675
79676     class Inst_FLAT__FLAT_STORE_DWORD : public Inst_FLAT
79677     {
79678       public:
79679         Inst_FLAT__FLAT_STORE_DWORD(InFmt_FLAT*);
79680         ~Inst_FLAT__FLAT_STORE_DWORD();
79681
79682         int
79683         getNumOperands() override
79684         {
79685             return numDstRegOperands() + numSrcRegOperands();
79686         } // getNumOperands
79687
79688         int numDstRegOperands() override { return 0; }
79689         int numSrcRegOperands() override { return 2; }
79690
79691         int
79692         getOperandSize(int opIdx) override
79693         {
79694             switch (opIdx) {
79695               case 0: //vgpr_addr
79696                 return 8;
79697               case 1: //vgpr_src
79698                 return 4;
79699               default:
79700                 fatal("op idx %i out of bounds\n", opIdx);
79701                 return -1;
79702             }
79703         } // getOperandSize
79704
79705         bool
79706         isSrcOperand(int opIdx) override
79707         {
79708             switch (opIdx) {
79709               case 0: //vgpr_addr
79710                 return true;
79711               case 1: //vgpr_src
79712                 return true;
79713               default:
79714                 fatal("op idx %i out of bounds\n", opIdx);
79715                 return false;
79716             }
79717         } // isSrcOperand
79718
79719         bool
79720         isDstOperand(int opIdx) override
79721         {
79722             switch (opIdx) {
79723               case 0: //vgpr_addr
79724                 return false;
79725               case 1: //vgpr_src
79726                 return false;
79727               default:
79728                 fatal("op idx %i out of bounds\n", opIdx);
79729                 return false;
79730             }
79731         } // isDstOperand
79732
79733         void execute(GPUDynInstPtr) override;
79734         void initiateAcc(GPUDynInstPtr) override;
79735         void completeAcc(GPUDynInstPtr) override;
79736     }; // Inst_FLAT__FLAT_STORE_DWORD
79737
79738     class Inst_FLAT__FLAT_STORE_DWORDX2 : public Inst_FLAT
79739     {
79740       public:
79741         Inst_FLAT__FLAT_STORE_DWORDX2(InFmt_FLAT*);
79742         ~Inst_FLAT__FLAT_STORE_DWORDX2();
79743
79744         int
79745         getNumOperands() override
79746         {
79747             return numDstRegOperands() + numSrcRegOperands();
79748         } // getNumOperands
79749
79750         int numDstRegOperands() override { return 0; }
79751         int numSrcRegOperands() override { return 2; }
79752
79753         int
79754         getOperandSize(int opIdx) override
79755         {
79756             switch (opIdx) {
79757               case 0: //vgpr_addr
79758                 return 8;
79759               case 1: //vgpr_src
79760                 return 8;
79761               default:
79762                 fatal("op idx %i out of bounds\n", opIdx);
79763                 return -1;
79764             }
79765         } // getOperandSize
79766
79767         bool
79768         isSrcOperand(int opIdx) override
79769         {
79770             switch (opIdx) {
79771               case 0: //vgpr_addr
79772                 return true;
79773               case 1: //vgpr_src
79774                 return true;
79775               default:
79776                 fatal("op idx %i out of bounds\n", opIdx);
79777                 return false;
79778             }
79779         } // isSrcOperand
79780
79781         bool
79782         isDstOperand(int opIdx) override
79783         {
79784             switch (opIdx) {
79785               case 0: //vgpr_addr
79786                 return false;
79787               case 1: //vgpr_src
79788                 return false;
79789               default:
79790                 fatal("op idx %i out of bounds\n", opIdx);
79791                 return false;
79792             }
79793         } // isDstOperand
79794
79795         void execute(GPUDynInstPtr) override;
79796         void initiateAcc(GPUDynInstPtr) override;
79797         void completeAcc(GPUDynInstPtr) override;
79798     }; // Inst_FLAT__FLAT_STORE_DWORDX2
79799
79800     class Inst_FLAT__FLAT_STORE_DWORDX3 : public Inst_FLAT
79801     {
79802       public:
79803         Inst_FLAT__FLAT_STORE_DWORDX3(InFmt_FLAT*);
79804         ~Inst_FLAT__FLAT_STORE_DWORDX3();
79805
79806         int
79807         getNumOperands() override
79808         {
79809             return numDstRegOperands() + numSrcRegOperands();
79810         } // getNumOperands
79811
79812         int numDstRegOperands() override { return 0; }
79813         int numSrcRegOperands() override { return 2; }
79814
79815         int
79816         getOperandSize(int opIdx) override
79817         {
79818             switch (opIdx) {
79819               case 0: //vgpr_addr
79820                 return 8;
79821               case 1: //vgpr_src
79822                 return 12;
79823               default:
79824                 fatal("op idx %i out of bounds\n", opIdx);
79825                 return -1;
79826             }
79827         } // getOperandSize
79828
79829         bool
79830         isSrcOperand(int opIdx) override
79831         {
79832             switch (opIdx) {
79833               case 0: //vgpr_addr
79834                 return true;
79835               case 1: //vgpr_src
79836                 return true;
79837               default:
79838                 fatal("op idx %i out of bounds\n", opIdx);
79839                 return false;
79840             }
79841         } // isSrcOperand
79842
79843         bool
79844         isDstOperand(int opIdx) override
79845         {
79846             switch (opIdx) {
79847               case 0: //vgpr_addr
79848                 return false;
79849               case 1: //vgpr_src
79850                 return false;
79851               default:
79852                 fatal("op idx %i out of bounds\n", opIdx);
79853                 return false;
79854             }
79855         } // isDstOperand
79856
79857         void execute(GPUDynInstPtr) override;
79858         void initiateAcc(GPUDynInstPtr) override;
79859         void completeAcc(GPUDynInstPtr) override;
79860     }; // Inst_FLAT__FLAT_STORE_DWORDX3
79861
79862     class Inst_FLAT__FLAT_STORE_DWORDX4 : public Inst_FLAT
79863     {
79864       public:
79865         Inst_FLAT__FLAT_STORE_DWORDX4(InFmt_FLAT*);
79866         ~Inst_FLAT__FLAT_STORE_DWORDX4();
79867
79868         int
79869         getNumOperands() override
79870         {
79871             return numDstRegOperands() + numSrcRegOperands();
79872         } // getNumOperands
79873
79874         int numDstRegOperands() override { return 0; }
79875         int numSrcRegOperands() override { return 2; }
79876
79877         int
79878         getOperandSize(int opIdx) override
79879         {
79880             switch (opIdx) {
79881               case 0: //vgpr_addr
79882                 return 8;
79883               case 1: //vgpr_src
79884                 return 16;
79885               default:
79886                 fatal("op idx %i out of bounds\n", opIdx);
79887                 return -1;
79888             }
79889         } // getOperandSize
79890
79891         bool
79892         isSrcOperand(int opIdx) override
79893         {
79894             switch (opIdx) {
79895               case 0: //vgpr_addr
79896                 return true;
79897               case 1: //vgpr_src
79898                 return true;
79899               default:
79900                 fatal("op idx %i out of bounds\n", opIdx);
79901                 return false;
79902             }
79903         } // isSrcOperand
79904
79905         bool
79906         isDstOperand(int opIdx) override
79907         {
79908             switch (opIdx) {
79909               case 0: //vgpr_addr
79910                 return false;
79911               case 1: //vgpr_src
79912                 return false;
79913               default:
79914                 fatal("op idx %i out of bounds\n", opIdx);
79915                 return false;
79916             }
79917         } // isDstOperand
79918
79919         void execute(GPUDynInstPtr) override;
79920         void initiateAcc(GPUDynInstPtr) override;
79921         void completeAcc(GPUDynInstPtr) override;
79922     }; // Inst_FLAT__FLAT_STORE_DWORDX4
79923
79924     class Inst_FLAT__FLAT_ATOMIC_SWAP : public Inst_FLAT
79925     {
79926       public:
79927         Inst_FLAT__FLAT_ATOMIC_SWAP(InFmt_FLAT*);
79928         ~Inst_FLAT__FLAT_ATOMIC_SWAP();
79929
79930         int
79931         getNumOperands() override
79932         {
79933             return numDstRegOperands() + numSrcRegOperands();
79934         } // getNumOperands
79935
79936         int numDstRegOperands() override { return 1; }
79937         int numSrcRegOperands() override { return 2; }
79938
79939         int
79940         getOperandSize(int opIdx) override
79941         {
79942             switch (opIdx) {
79943               case 0: //vgpr_addr
79944                 return 8;
79945               case 1: //vgpr_src
79946                 return 4;
79947               case 2: //vgpr_dst
79948                 return 4;
79949               default:
79950                 fatal("op idx %i out of bounds\n", opIdx);
79951                 return -1;
79952             }
79953         } // getOperandSize
79954
79955         bool
79956         isSrcOperand(int opIdx) override
79957         {
79958             switch (opIdx) {
79959               case 0: //vgpr_addr
79960                 return true;
79961               case 1: //vgpr_src
79962                 return true;
79963               case 2: //vgpr_dst
79964                 return false;
79965               default:
79966                 fatal("op idx %i out of bounds\n", opIdx);
79967                 return false;
79968             }
79969         } // isSrcOperand
79970
79971         bool
79972         isDstOperand(int opIdx) override
79973         {
79974             switch (opIdx) {
79975               case 0: //vgpr_addr
79976                 return false;
79977               case 1: //vgpr_src
79978                 return false;
79979               case 2: //vgpr_dst
79980                 return true;
79981               default:
79982                 fatal("op idx %i out of bounds\n", opIdx);
79983                 return false;
79984             }
79985         } // isDstOperand
79986
79987         void execute(GPUDynInstPtr) override;
79988         void initiateAcc(GPUDynInstPtr) override;
79989         void completeAcc(GPUDynInstPtr) override;
79990     }; // Inst_FLAT__FLAT_ATOMIC_SWAP
79991
79992     class Inst_FLAT__FLAT_ATOMIC_CMPSWAP : public Inst_FLAT
79993     {
79994       public:
79995         Inst_FLAT__FLAT_ATOMIC_CMPSWAP(InFmt_FLAT*);
79996         ~Inst_FLAT__FLAT_ATOMIC_CMPSWAP();
79997
79998         int
79999         getNumOperands() override
80000         {
80001             return numDstRegOperands() + numSrcRegOperands();
80002         } // getNumOperands
80003
80004         int numDstRegOperands() override { return 1; }
80005         int numSrcRegOperands() override { return 2; }
80006
80007         int
80008         getOperandSize(int opIdx) override
80009         {
80010             switch (opIdx) {
80011               case 0: //vgpr_addr
80012                 return 8;
80013               case 1: //vgpr_src
80014                 return 8;
80015               case 2: //vgpr_dst
80016                 return 4;
80017               default:
80018                 fatal("op idx %i out of bounds\n", opIdx);
80019                 return -1;
80020             }
80021         } // getOperandSize
80022
80023         bool
80024         isSrcOperand(int opIdx) override
80025         {
80026             switch (opIdx) {
80027               case 0: //vgpr_addr
80028                 return true;
80029               case 1: //vgpr_src
80030                 return true;
80031               case 2: //vgpr_dst
80032                 return false;
80033               default:
80034                 fatal("op idx %i out of bounds\n", opIdx);
80035                 return false;
80036             }
80037         } // isSrcOperand
80038
80039         bool
80040         isDstOperand(int opIdx) override
80041         {
80042             switch (opIdx) {
80043               case 0: //vgpr_addr
80044                 return false;
80045               case 1: //vgpr_src
80046                 return false;
80047               case 2: //vgpr_dst
80048                 return true;
80049               default:
80050                 fatal("op idx %i out of bounds\n", opIdx);
80051                 return false;
80052             }
80053         } // isDstOperand
80054
80055         void execute(GPUDynInstPtr) override;
80056         void initiateAcc(GPUDynInstPtr) override;
80057         void completeAcc(GPUDynInstPtr) override;
80058     }; // Inst_FLAT__FLAT_ATOMIC_CMPSWAP
80059
80060     class Inst_FLAT__FLAT_ATOMIC_ADD : public Inst_FLAT
80061     {
80062       public:
80063         Inst_FLAT__FLAT_ATOMIC_ADD(InFmt_FLAT*);
80064         ~Inst_FLAT__FLAT_ATOMIC_ADD();
80065
80066         int
80067         getNumOperands() override
80068         {
80069             return numDstRegOperands() + numSrcRegOperands();
80070         } // getNumOperands
80071
80072         int numDstRegOperands() override { return 1; }
80073         int numSrcRegOperands() override { return 2; }
80074
80075         int
80076         getOperandSize(int opIdx) override
80077         {
80078             switch (opIdx) {
80079               case 0: //vgpr_addr
80080                 return 8;
80081               case 1: //vgpr_src
80082                 return 4;
80083               case 2: //vgpr_dst
80084                 return 4;
80085               default:
80086                 fatal("op idx %i out of bounds\n", opIdx);
80087                 return -1;
80088             }
80089         } // getOperandSize
80090
80091         bool
80092         isSrcOperand(int opIdx) override
80093         {
80094             switch (opIdx) {
80095               case 0: //vgpr_addr
80096                 return true;
80097               case 1: //vgpr_src
80098                 return true;
80099               case 2: //vgpr_dst
80100                 return false;
80101               default:
80102                 fatal("op idx %i out of bounds\n", opIdx);
80103                 return false;
80104             }
80105         } // isSrcOperand
80106
80107         bool
80108         isDstOperand(int opIdx) override
80109         {
80110             switch (opIdx) {
80111               case 0: //vgpr_addr
80112                 return false;
80113               case 1: //vgpr_src
80114                 return false;
80115               case 2: //vgpr_dst
80116                 return true;
80117               default:
80118                 fatal("op idx %i out of bounds\n", opIdx);
80119                 return false;
80120             }
80121         } // isDstOperand
80122
80123         void execute(GPUDynInstPtr) override;
80124         void initiateAcc(GPUDynInstPtr) override;
80125         void completeAcc(GPUDynInstPtr) override;
80126     }; // Inst_FLAT__FLAT_ATOMIC_ADD
80127
80128     class Inst_FLAT__FLAT_ATOMIC_SUB : public Inst_FLAT
80129     {
80130       public:
80131         Inst_FLAT__FLAT_ATOMIC_SUB(InFmt_FLAT*);
80132         ~Inst_FLAT__FLAT_ATOMIC_SUB();
80133
80134         int
80135         getNumOperands() override
80136         {
80137             return numDstRegOperands() + numSrcRegOperands();
80138         } // getNumOperands
80139
80140         int numDstRegOperands() override { return 1; }
80141         int numSrcRegOperands() override { return 2; }
80142
80143         int
80144         getOperandSize(int opIdx) override
80145         {
80146             switch (opIdx) {
80147               case 0: //vgpr_addr
80148                 return 8;
80149               case 1: //vgpr_src
80150                 return 32;
80151               case 2: //vgpr_dst
80152                 return 32;
80153               default:
80154                 fatal("op idx %i out of bounds\n", opIdx);
80155                 return -1;
80156             }
80157         } // getOperandSize
80158
80159         bool
80160         isSrcOperand(int opIdx) override
80161         {
80162             switch (opIdx) {
80163               case 0: //vgpr_addr
80164                 return true;
80165               case 1: //vgpr_src
80166                 return true;
80167               case 2: //vgpr_dst
80168                 return false;
80169               default:
80170                 fatal("op idx %i out of bounds\n", opIdx);
80171                 return false;
80172             }
80173         } // isSrcOperand
80174
80175         bool
80176         isDstOperand(int opIdx) override
80177         {
80178             switch (opIdx) {
80179               case 0: //vgpr_addr
80180                 return false;
80181               case 1: //vgpr_src
80182                 return false;
80183               case 2: //vgpr_dst
80184                 return true;
80185               default:
80186                 fatal("op idx %i out of bounds\n", opIdx);
80187                 return false;
80188             }
80189         } // isDstOperand
80190
80191         void execute(GPUDynInstPtr) override;
80192         void initiateAcc(GPUDynInstPtr) override;
80193         void completeAcc(GPUDynInstPtr) override;
80194     }; // Inst_FLAT__FLAT_ATOMIC_SUB
80195
80196     class Inst_FLAT__FLAT_ATOMIC_SMIN : public Inst_FLAT
80197     {
80198       public:
80199         Inst_FLAT__FLAT_ATOMIC_SMIN(InFmt_FLAT*);
80200         ~Inst_FLAT__FLAT_ATOMIC_SMIN();
80201
80202         int
80203         getNumOperands() override
80204         {
80205             return numDstRegOperands() + numSrcRegOperands();
80206         } // getNumOperands
80207
80208         int numDstRegOperands() override { return 1; }
80209         int numSrcRegOperands() override { return 2; }
80210
80211         int
80212         getOperandSize(int opIdx) override
80213         {
80214             switch (opIdx) {
80215               case 0: //vgpr_addr
80216                 return 8;
80217               case 1: //vgpr_src
80218                 return 32;
80219               case 2: //vgpr_dst
80220                 return 32;
80221               default:
80222                 fatal("op idx %i out of bounds\n", opIdx);
80223                 return -1;
80224             }
80225         } // getOperandSize
80226
80227         bool
80228         isSrcOperand(int opIdx) override
80229         {
80230             switch (opIdx) {
80231               case 0: //vgpr_addr
80232                 return true;
80233               case 1: //vgpr_src
80234                 return true;
80235               case 2: //vgpr_dst
80236                 return false;
80237               default:
80238                 fatal("op idx %i out of bounds\n", opIdx);
80239                 return false;
80240             }
80241         } // isSrcOperand
80242
80243         bool
80244         isDstOperand(int opIdx) override
80245         {
80246             switch (opIdx) {
80247               case 0: //vgpr_addr
80248                 return false;
80249               case 1: //vgpr_src
80250                 return false;
80251               case 2: //vgpr_dst
80252                 return true;
80253               default:
80254                 fatal("op idx %i out of bounds\n", opIdx);
80255                 return false;
80256             }
80257         } // isDstOperand
80258
80259         void execute(GPUDynInstPtr) override;
80260     }; // Inst_FLAT__FLAT_ATOMIC_SMIN
80261
80262     class Inst_FLAT__FLAT_ATOMIC_UMIN : public Inst_FLAT
80263     {
80264       public:
80265         Inst_FLAT__FLAT_ATOMIC_UMIN(InFmt_FLAT*);
80266         ~Inst_FLAT__FLAT_ATOMIC_UMIN();
80267
80268         int
80269         getNumOperands() override
80270         {
80271             return numDstRegOperands() + numSrcRegOperands();
80272         } // getNumOperands
80273
80274         int numDstRegOperands() override { return 1; }
80275         int numSrcRegOperands() override { return 2; }
80276
80277         int
80278         getOperandSize(int opIdx) override
80279         {
80280             switch (opIdx) {
80281               case 0: //vgpr_addr
80282                 return 8;
80283               case 1: //vgpr_src
80284                 return 32;
80285               case 2: //vgpr_dst
80286                 return 32;
80287               default:
80288                 fatal("op idx %i out of bounds\n", opIdx);
80289                 return -1;
80290             }
80291         } // getOperandSize
80292
80293         bool
80294         isSrcOperand(int opIdx) override
80295         {
80296             switch (opIdx) {
80297               case 0: //vgpr_addr
80298                 return true;
80299               case 1: //vgpr_src
80300                 return true;
80301               case 2: //vgpr_dst
80302                 return false;
80303               default:
80304                 fatal("op idx %i out of bounds\n", opIdx);
80305                 return false;
80306             }
80307         } // isSrcOperand
80308
80309         bool
80310         isDstOperand(int opIdx) override
80311         {
80312             switch (opIdx) {
80313               case 0: //vgpr_addr
80314                 return false;
80315               case 1: //vgpr_src
80316                 return false;
80317               case 2: //vgpr_dst
80318                 return true;
80319               default:
80320                 fatal("op idx %i out of bounds\n", opIdx);
80321                 return false;
80322             }
80323         } // isDstOperand
80324
80325         void execute(GPUDynInstPtr) override;
80326     }; // Inst_FLAT__FLAT_ATOMIC_UMIN
80327
80328     class Inst_FLAT__FLAT_ATOMIC_SMAX : public Inst_FLAT
80329     {
80330       public:
80331         Inst_FLAT__FLAT_ATOMIC_SMAX(InFmt_FLAT*);
80332         ~Inst_FLAT__FLAT_ATOMIC_SMAX();
80333
80334         int
80335         getNumOperands() override
80336         {
80337             return numDstRegOperands() + numSrcRegOperands();
80338         } // getNumOperands
80339
80340         int numDstRegOperands() override { return 1; }
80341         int numSrcRegOperands() override { return 2; }
80342
80343         int
80344         getOperandSize(int opIdx) override
80345         {
80346             switch (opIdx) {
80347               case 0: //vgpr_addr
80348                 return 8;
80349               case 1: //vgpr_src
80350                 return 32;
80351               case 2: //vgpr_dst
80352                 return 32;
80353               default:
80354                 fatal("op idx %i out of bounds\n", opIdx);
80355                 return -1;
80356             }
80357         } // getOperandSize
80358
80359         bool
80360         isSrcOperand(int opIdx) override
80361         {
80362             switch (opIdx) {
80363               case 0: //vgpr_addr
80364                 return true;
80365               case 1: //vgpr_src
80366                 return true;
80367               case 2: //vgpr_dst
80368                 return false;
80369               default:
80370                 fatal("op idx %i out of bounds\n", opIdx);
80371                 return false;
80372             }
80373         } // isSrcOperand
80374
80375         bool
80376         isDstOperand(int opIdx) override
80377         {
80378             switch (opIdx) {
80379               case 0: //vgpr_addr
80380                 return false;
80381               case 1: //vgpr_src
80382                 return false;
80383               case 2: //vgpr_dst
80384                 return true;
80385               default:
80386                 fatal("op idx %i out of bounds\n", opIdx);
80387                 return false;
80388             }
80389         } // isDstOperand
80390
80391         void execute(GPUDynInstPtr) override;
80392     }; // Inst_FLAT__FLAT_ATOMIC_SMAX
80393
80394     class Inst_FLAT__FLAT_ATOMIC_UMAX : public Inst_FLAT
80395     {
80396       public:
80397         Inst_FLAT__FLAT_ATOMIC_UMAX(InFmt_FLAT*);
80398         ~Inst_FLAT__FLAT_ATOMIC_UMAX();
80399
80400         int
80401         getNumOperands() override
80402         {
80403             return numDstRegOperands() + numSrcRegOperands();
80404         } // getNumOperands
80405
80406         int numDstRegOperands() override { return 1; }
80407         int numSrcRegOperands() override { return 2; }
80408
80409         int
80410         getOperandSize(int opIdx) override
80411         {
80412             switch (opIdx) {
80413               case 0: //vgpr_addr
80414                 return 8;
80415               case 1: //vgpr_src
80416                 return 32;
80417               case 2: //vgpr_dst
80418                 return 32;
80419               default:
80420                 fatal("op idx %i out of bounds\n", opIdx);
80421                 return -1;
80422             }
80423         } // getOperandSize
80424
80425         bool
80426         isSrcOperand(int opIdx) override
80427         {
80428             switch (opIdx) {
80429               case 0: //vgpr_addr
80430                 return true;
80431               case 1: //vgpr_src
80432                 return true;
80433               case 2: //vgpr_dst
80434                 return false;
80435               default:
80436                 fatal("op idx %i out of bounds\n", opIdx);
80437                 return false;
80438             }
80439         } // isSrcOperand
80440
80441         bool
80442         isDstOperand(int opIdx) override
80443         {
80444             switch (opIdx) {
80445               case 0: //vgpr_addr
80446                 return false;
80447               case 1: //vgpr_src
80448                 return false;
80449               case 2: //vgpr_dst
80450                 return true;
80451               default:
80452                 fatal("op idx %i out of bounds\n", opIdx);
80453                 return false;
80454             }
80455         } // isDstOperand
80456
80457         void execute(GPUDynInstPtr) override;
80458     }; // Inst_FLAT__FLAT_ATOMIC_UMAX
80459
80460     class Inst_FLAT__FLAT_ATOMIC_AND : public Inst_FLAT
80461     {
80462       public:
80463         Inst_FLAT__FLAT_ATOMIC_AND(InFmt_FLAT*);
80464         ~Inst_FLAT__FLAT_ATOMIC_AND();
80465
80466         int
80467         getNumOperands() override
80468         {
80469             return numDstRegOperands() + numSrcRegOperands();
80470         } // getNumOperands
80471
80472         int numDstRegOperands() override { return 1; }
80473         int numSrcRegOperands() override { return 2; }
80474
80475         int
80476         getOperandSize(int opIdx) override
80477         {
80478             switch (opIdx) {
80479               case 0: //vgpr_addr
80480                 return 8;
80481               case 1: //vgpr_src
80482                 return 32;
80483               case 2: //vgpr_dst
80484                 return 32;
80485               default:
80486                 fatal("op idx %i out of bounds\n", opIdx);
80487                 return -1;
80488             }
80489         } // getOperandSize
80490
80491         bool
80492         isSrcOperand(int opIdx) override
80493         {
80494             switch (opIdx) {
80495               case 0: //vgpr_addr
80496                 return true;
80497               case 1: //vgpr_src
80498                 return true;
80499               case 2: //vgpr_dst
80500                 return false;
80501               default:
80502                 fatal("op idx %i out of bounds\n", opIdx);
80503                 return false;
80504             }
80505         } // isSrcOperand
80506
80507         bool
80508         isDstOperand(int opIdx) override
80509         {
80510             switch (opIdx) {
80511               case 0: //vgpr_addr
80512                 return false;
80513               case 1: //vgpr_src
80514                 return false;
80515               case 2: //vgpr_dst
80516                 return true;
80517               default:
80518                 fatal("op idx %i out of bounds\n", opIdx);
80519                 return false;
80520             }
80521         } // isDstOperand
80522
80523         void execute(GPUDynInstPtr) override;
80524     }; // Inst_FLAT__FLAT_ATOMIC_AND
80525
80526     class Inst_FLAT__FLAT_ATOMIC_OR : public Inst_FLAT
80527     {
80528       public:
80529         Inst_FLAT__FLAT_ATOMIC_OR(InFmt_FLAT*);
80530         ~Inst_FLAT__FLAT_ATOMIC_OR();
80531
80532         int
80533         getNumOperands() override
80534         {
80535             return numDstRegOperands() + numSrcRegOperands();
80536         } // getNumOperands
80537
80538         int numDstRegOperands() override { return 1; }
80539         int numSrcRegOperands() override { return 2; }
80540
80541         int
80542         getOperandSize(int opIdx) override
80543         {
80544             switch (opIdx) {
80545               case 0: //vgpr_addr
80546                 return 8;
80547               case 1: //vgpr_src
80548                 return 32;
80549               case 2: //vgpr_dst
80550                 return 32;
80551               default:
80552                 fatal("op idx %i out of bounds\n", opIdx);
80553                 return -1;
80554             }
80555         } // getOperandSize
80556
80557         bool
80558         isSrcOperand(int opIdx) override
80559         {
80560             switch (opIdx) {
80561               case 0: //vgpr_addr
80562                 return true;
80563               case 1: //vgpr_src
80564                 return true;
80565               case 2: //vgpr_dst
80566                 return false;
80567               default:
80568                 fatal("op idx %i out of bounds\n", opIdx);
80569                 return false;
80570             }
80571         } // isSrcOperand
80572
80573         bool
80574         isDstOperand(int opIdx) override
80575         {
80576             switch (opIdx) {
80577               case 0: //vgpr_addr
80578                 return false;
80579               case 1: //vgpr_src
80580                 return false;
80581               case 2: //vgpr_dst
80582                 return true;
80583               default:
80584                 fatal("op idx %i out of bounds\n", opIdx);
80585                 return false;
80586             }
80587         } // isDstOperand
80588
80589         void execute(GPUDynInstPtr) override;
80590     }; // Inst_FLAT__FLAT_ATOMIC_OR
80591
80592     class Inst_FLAT__FLAT_ATOMIC_XOR : public Inst_FLAT
80593     {
80594       public:
80595         Inst_FLAT__FLAT_ATOMIC_XOR(InFmt_FLAT*);
80596         ~Inst_FLAT__FLAT_ATOMIC_XOR();
80597
80598         int
80599         getNumOperands() override
80600         {
80601             return numDstRegOperands() + numSrcRegOperands();
80602         } // getNumOperands
80603
80604         int numDstRegOperands() override { return 1; }
80605         int numSrcRegOperands() override { return 2; }
80606
80607         int
80608         getOperandSize(int opIdx) override
80609         {
80610             switch (opIdx) {
80611               case 0: //vgpr_addr
80612                 return 8;
80613               case 1: //vgpr_src
80614                 return 32;
80615               case 2: //vgpr_dst
80616                 return 32;
80617               default:
80618                 fatal("op idx %i out of bounds\n", opIdx);
80619                 return -1;
80620             }
80621         } // getOperandSize
80622
80623         bool
80624         isSrcOperand(int opIdx) override
80625         {
80626             switch (opIdx) {
80627               case 0: //vgpr_addr
80628                 return true;
80629               case 1: //vgpr_src
80630                 return true;
80631               case 2: //vgpr_dst
80632                 return false;
80633               default:
80634                 fatal("op idx %i out of bounds\n", opIdx);
80635                 return false;
80636             }
80637         } // isSrcOperand
80638
80639         bool
80640         isDstOperand(int opIdx) override
80641         {
80642             switch (opIdx) {
80643               case 0: //vgpr_addr
80644                 return false;
80645               case 1: //vgpr_src
80646                 return false;
80647               case 2: //vgpr_dst
80648                 return true;
80649               default:
80650                 fatal("op idx %i out of bounds\n", opIdx);
80651                 return false;
80652             }
80653         } // isDstOperand
80654
80655         void execute(GPUDynInstPtr) override;
80656     }; // Inst_FLAT__FLAT_ATOMIC_XOR
80657
80658     class Inst_FLAT__FLAT_ATOMIC_INC : public Inst_FLAT
80659     {
80660       public:
80661         Inst_FLAT__FLAT_ATOMIC_INC(InFmt_FLAT*);
80662         ~Inst_FLAT__FLAT_ATOMIC_INC();
80663
80664         int
80665         getNumOperands() override
80666         {
80667             return numDstRegOperands() + numSrcRegOperands();
80668         } // getNumOperands
80669
80670         int numDstRegOperands() override { return 1; }
80671         int numSrcRegOperands() override { return 2; }
80672
80673         int
80674         getOperandSize(int opIdx) override
80675         {
80676             switch (opIdx) {
80677               case 0: //vgpr_addr
80678                 return 8;
80679               case 1: //vgpr_src
80680                 return 32;
80681               case 2: //vgpr_dst
80682                 return 32;
80683               default:
80684                 fatal("op idx %i out of bounds\n", opIdx);
80685                 return -1;
80686             }
80687         } // getOperandSize
80688
80689         bool
80690         isSrcOperand(int opIdx) override
80691         {
80692             switch (opIdx) {
80693               case 0: //vgpr_addr
80694                 return true;
80695               case 1: //vgpr_src
80696                 return true;
80697               case 2: //vgpr_dst
80698                 return false;
80699               default:
80700                 fatal("op idx %i out of bounds\n", opIdx);
80701                 return false;
80702             }
80703         } // isSrcOperand
80704
80705         bool
80706         isDstOperand(int opIdx) override
80707         {
80708             switch (opIdx) {
80709               case 0: //vgpr_addr
80710                 return false;
80711               case 1: //vgpr_src
80712                 return false;
80713               case 2: //vgpr_dst
80714                 return true;
80715               default:
80716                 fatal("op idx %i out of bounds\n", opIdx);
80717                 return false;
80718             }
80719         } // isDstOperand
80720
80721         void execute(GPUDynInstPtr) override;
80722         void initiateAcc(GPUDynInstPtr) override;
80723         void completeAcc(GPUDynInstPtr) override;
80724     }; // Inst_FLAT__FLAT_ATOMIC_INC
80725
80726     class Inst_FLAT__FLAT_ATOMIC_DEC : public Inst_FLAT
80727     {
80728       public:
80729         Inst_FLAT__FLAT_ATOMIC_DEC(InFmt_FLAT*);
80730         ~Inst_FLAT__FLAT_ATOMIC_DEC();
80731
80732         int
80733         getNumOperands() override
80734         {
80735             return numDstRegOperands() + numSrcRegOperands();
80736         } // getNumOperands
80737
80738         int numDstRegOperands() override { return 1; }
80739         int numSrcRegOperands() override { return 2; }
80740
80741         int
80742         getOperandSize(int opIdx) override
80743         {
80744             switch (opIdx) {
80745               case 0: //vgpr_addr
80746                 return 8;
80747               case 1: //vgpr_src
80748                 return 32;
80749               case 2: //vgpr_dst
80750                 return 32;
80751               default:
80752                 fatal("op idx %i out of bounds\n", opIdx);
80753                 return -1;
80754             }
80755         } // getOperandSize
80756
80757         bool
80758         isSrcOperand(int opIdx) override
80759         {
80760             switch (opIdx) {
80761               case 0: //vgpr_addr
80762                 return true;
80763               case 1: //vgpr_src
80764                 return true;
80765               case 2: //vgpr_dst
80766                 return false;
80767               default:
80768                 fatal("op idx %i out of bounds\n", opIdx);
80769                 return false;
80770             }
80771         } // isSrcOperand
80772
80773         bool
80774         isDstOperand(int opIdx) override
80775         {
80776             switch (opIdx) {
80777               case 0: //vgpr_addr
80778                 return false;
80779               case 1: //vgpr_src
80780                 return false;
80781               case 2: //vgpr_dst
80782                 return true;
80783               default:
80784                 fatal("op idx %i out of bounds\n", opIdx);
80785                 return false;
80786             }
80787         } // isDstOperand
80788
80789         void execute(GPUDynInstPtr) override;
80790         void initiateAcc(GPUDynInstPtr) override;
80791         void completeAcc(GPUDynInstPtr) override;
80792     }; // Inst_FLAT__FLAT_ATOMIC_DEC
80793
80794     class Inst_FLAT__FLAT_ATOMIC_SWAP_X2 : public Inst_FLAT
80795     {
80796       public:
80797         Inst_FLAT__FLAT_ATOMIC_SWAP_X2(InFmt_FLAT*);
80798         ~Inst_FLAT__FLAT_ATOMIC_SWAP_X2();
80799
80800         int
80801         getNumOperands() override
80802         {
80803             return numDstRegOperands() + numSrcRegOperands();
80804         } // getNumOperands
80805
80806         int numDstRegOperands() override { return 1; }
80807         int numSrcRegOperands() override { return 2; }
80808
80809         int
80810         getOperandSize(int opIdx) override
80811         {
80812             switch (opIdx) {
80813               case 0: //vgpr_addr
80814                 return 8;
80815               case 1: //vgpr_src
80816                 return 8;
80817               case 2: //vgpr_dst
80818                 return 8;
80819               default:
80820                 fatal("op idx %i out of bounds\n", opIdx);
80821                 return -1;
80822             }
80823         } // getOperandSize
80824
80825         bool
80826         isSrcOperand(int opIdx) override
80827         {
80828             switch (opIdx) {
80829               case 0: //vgpr_addr
80830                 return true;
80831               case 1: //vgpr_src
80832                 return true;
80833               case 2: //vgpr_dst
80834                 return false;
80835               default:
80836                 fatal("op idx %i out of bounds\n", opIdx);
80837                 return false;
80838             }
80839         } // isSrcOperand
80840
80841         bool
80842         isDstOperand(int opIdx) override
80843         {
80844             switch (opIdx) {
80845               case 0: //vgpr_addr
80846                 return false;
80847               case 1: //vgpr_src
80848                 return false;
80849               case 2: //vgpr_dst
80850                 return true;
80851               default:
80852                 fatal("op idx %i out of bounds\n", opIdx);
80853                 return false;
80854             }
80855         } // isDstOperand
80856
80857         void execute(GPUDynInstPtr) override;
80858     }; // Inst_FLAT__FLAT_ATOMIC_SWAP_X2
80859
80860     class Inst_FLAT__FLAT_ATOMIC_CMPSWAP_X2 : public Inst_FLAT
80861     {
80862       public:
80863         Inst_FLAT__FLAT_ATOMIC_CMPSWAP_X2(InFmt_FLAT*);
80864         ~Inst_FLAT__FLAT_ATOMIC_CMPSWAP_X2();
80865
80866         int
80867         getNumOperands() override
80868         {
80869             return numDstRegOperands() + numSrcRegOperands();
80870         } // getNumOperands
80871
80872         int numDstRegOperands() override { return 1; }
80873         int numSrcRegOperands() override { return 2; }
80874
80875         int
80876         getOperandSize(int opIdx) override
80877         {
80878             switch (opIdx) {
80879               case 0: //vgpr_addr
80880                 return 8;
80881               case 1: //vgpr_src
80882                 return 16;
80883               case 2: //vgpr_dst
80884                 return 8;
80885               default:
80886                 fatal("op idx %i out of bounds\n", opIdx);
80887                 return -1;
80888             }
80889         } // getOperandSize
80890
80891         bool
80892         isSrcOperand(int opIdx) override
80893         {
80894             switch (opIdx) {
80895               case 0: //vgpr_addr
80896                 return true;
80897               case 1: //vgpr_src
80898                 return true;
80899               case 2: //vgpr_dst
80900                 return false;
80901               default:
80902                 fatal("op idx %i out of bounds\n", opIdx);
80903                 return false;
80904             }
80905         } // isSrcOperand
80906
80907         bool
80908         isDstOperand(int opIdx) override
80909         {
80910             switch (opIdx) {
80911               case 0: //vgpr_addr
80912                 return false;
80913               case 1: //vgpr_src
80914                 return false;
80915               case 2: //vgpr_dst
80916                 return true;
80917               default:
80918                 fatal("op idx %i out of bounds\n", opIdx);
80919                 return false;
80920             }
80921         } // isDstOperand
80922
80923         void execute(GPUDynInstPtr) override;
80924         void initiateAcc(GPUDynInstPtr) override;
80925         void completeAcc(GPUDynInstPtr) override;
80926     }; // Inst_FLAT__FLAT_ATOMIC_CMPSWAP_X2
80927
80928     class Inst_FLAT__FLAT_ATOMIC_ADD_X2 : public Inst_FLAT
80929     {
80930       public:
80931         Inst_FLAT__FLAT_ATOMIC_ADD_X2(InFmt_FLAT*);
80932         ~Inst_FLAT__FLAT_ATOMIC_ADD_X2();
80933
80934         int
80935         getNumOperands() override
80936         {
80937             return numDstRegOperands() + numSrcRegOperands();
80938         } // getNumOperands
80939
80940         int numDstRegOperands() override { return 1; }
80941         int numSrcRegOperands() override { return 2; }
80942
80943         int
80944         getOperandSize(int opIdx) override
80945         {
80946             switch (opIdx) {
80947               case 0: //vgpr_addr
80948                 return 8;
80949               case 1: //vgpr_src
80950                 return 8;
80951               case 2: //vgpr_dst
80952                 return 8;
80953               default:
80954                 fatal("op idx %i out of bounds\n", opIdx);
80955                 return -1;
80956             }
80957         } // getOperandSize
80958
80959         bool
80960         isSrcOperand(int opIdx) override
80961         {
80962             switch (opIdx) {
80963               case 0: //vgpr_addr
80964                 return true;
80965               case 1: //vgpr_src
80966                 return true;
80967               case 2: //vgpr_dst
80968                 return false;
80969               default:
80970                 fatal("op idx %i out of bounds\n", opIdx);
80971                 return false;
80972             }
80973         } // isSrcOperand
80974
80975         bool
80976         isDstOperand(int opIdx) override
80977         {
80978             switch (opIdx) {
80979               case 0: //vgpr_addr
80980                 return false;
80981               case 1: //vgpr_src
80982                 return false;
80983               case 2: //vgpr_dst
80984                 return true;
80985               default:
80986                 fatal("op idx %i out of bounds\n", opIdx);
80987                 return false;
80988             }
80989         } // isDstOperand
80990
80991         void execute(GPUDynInstPtr) override;
80992         void initiateAcc(GPUDynInstPtr) override;
80993         void completeAcc(GPUDynInstPtr) override;
80994     }; // Inst_FLAT__FLAT_ATOMIC_ADD_X2
80995
80996     class Inst_FLAT__FLAT_ATOMIC_SUB_X2 : public Inst_FLAT
80997     {
80998       public:
80999         Inst_FLAT__FLAT_ATOMIC_SUB_X2(InFmt_FLAT*);
81000         ~Inst_FLAT__FLAT_ATOMIC_SUB_X2();
81001
81002         int
81003         getNumOperands() override
81004         {
81005             return numDstRegOperands() + numSrcRegOperands();
81006         } // getNumOperands
81007
81008         int numDstRegOperands() override { return 1; }
81009         int numSrcRegOperands() override { return 2; }
81010
81011         int
81012         getOperandSize(int opIdx) override
81013         {
81014             switch (opIdx) {
81015               case 0: //vgpr_addr
81016                 return 8;
81017               case 1: //vgpr_src
81018                 return 8;
81019               case 2: //vgpr_dst
81020                 return 8;
81021               default:
81022                 fatal("op idx %i out of bounds\n", opIdx);
81023                 return -1;
81024             }
81025         } // getOperandSize
81026
81027         bool
81028         isSrcOperand(int opIdx) override
81029         {
81030             switch (opIdx) {
81031               case 0: //vgpr_addr
81032                 return true;
81033               case 1: //vgpr_src
81034                 return true;
81035               case 2: //vgpr_dst
81036                 return false;
81037               default:
81038                 fatal("op idx %i out of bounds\n", opIdx);
81039                 return false;
81040             }
81041         } // isSrcOperand
81042
81043         bool
81044         isDstOperand(int opIdx) override
81045         {
81046             switch (opIdx) {
81047               case 0: //vgpr_addr
81048                 return false;
81049               case 1: //vgpr_src
81050                 return false;
81051               case 2: //vgpr_dst
81052                 return true;
81053               default:
81054                 fatal("op idx %i out of bounds\n", opIdx);
81055                 return false;
81056             }
81057         } // isDstOperand
81058
81059         void execute(GPUDynInstPtr) override;
81060         void initiateAcc(GPUDynInstPtr) override;
81061         void completeAcc(GPUDynInstPtr) override;
81062     }; // Inst_FLAT__FLAT_ATOMIC_SUB_X2
81063
81064     class Inst_FLAT__FLAT_ATOMIC_SMIN_X2 : public Inst_FLAT
81065     {
81066       public:
81067         Inst_FLAT__FLAT_ATOMIC_SMIN_X2(InFmt_FLAT*);
81068         ~Inst_FLAT__FLAT_ATOMIC_SMIN_X2();
81069
81070         int
81071         getNumOperands() override
81072         {
81073             return numDstRegOperands() + numSrcRegOperands();
81074         } // getNumOperands
81075
81076         int numDstRegOperands() override { return 1; }
81077         int numSrcRegOperands() override { return 2; }
81078
81079         int
81080         getOperandSize(int opIdx) override
81081         {
81082             switch (opIdx) {
81083               case 0: //vgpr_addr
81084                 return 8;
81085               case 1: //vgpr_src
81086                 return 8;
81087               case 2: //vgpr_dst
81088                 return 8;
81089               default:
81090                 fatal("op idx %i out of bounds\n", opIdx);
81091                 return -1;
81092             }
81093         } // getOperandSize
81094
81095         bool
81096         isSrcOperand(int opIdx) override
81097         {
81098             switch (opIdx) {
81099               case 0: //vgpr_addr
81100                 return true;
81101               case 1: //vgpr_src
81102                 return true;
81103               case 2: //vgpr_dst
81104                 return false;
81105               default:
81106                 fatal("op idx %i out of bounds\n", opIdx);
81107                 return false;
81108             }
81109         } // isSrcOperand
81110
81111         bool
81112         isDstOperand(int opIdx) override
81113         {
81114             switch (opIdx) {
81115               case 0: //vgpr_addr
81116                 return false;
81117               case 1: //vgpr_src
81118                 return false;
81119               case 2: //vgpr_dst
81120                 return true;
81121               default:
81122                 fatal("op idx %i out of bounds\n", opIdx);
81123                 return false;
81124             }
81125         } // isDstOperand
81126
81127         void execute(GPUDynInstPtr) override;
81128     }; // Inst_FLAT__FLAT_ATOMIC_SMIN_X2
81129
81130     class Inst_FLAT__FLAT_ATOMIC_UMIN_X2 : public Inst_FLAT
81131     {
81132       public:
81133         Inst_FLAT__FLAT_ATOMIC_UMIN_X2(InFmt_FLAT*);
81134         ~Inst_FLAT__FLAT_ATOMIC_UMIN_X2();
81135
81136         int
81137         getNumOperands() override
81138         {
81139             return numDstRegOperands() + numSrcRegOperands();
81140         } // getNumOperands
81141
81142         int numDstRegOperands() override { return 1; }
81143         int numSrcRegOperands() override { return 2; }
81144
81145         int
81146         getOperandSize(int opIdx) override
81147         {
81148             switch (opIdx) {
81149               case 0: //vgpr_addr
81150                 return 8;
81151               case 1: //vgpr_src
81152                 return 8;
81153               case 2: //vgpr_dst
81154                 return 8;
81155               default:
81156                 fatal("op idx %i out of bounds\n", opIdx);
81157                 return -1;
81158             }
81159         } // getOperandSize
81160
81161         bool
81162         isSrcOperand(int opIdx) override
81163         {
81164             switch (opIdx) {
81165               case 0: //vgpr_addr
81166                 return true;
81167               case 1: //vgpr_src
81168                 return true;
81169               case 2: //vgpr_dst
81170                 return false;
81171               default:
81172                 fatal("op idx %i out of bounds\n", opIdx);
81173                 return false;
81174             }
81175         } // isSrcOperand
81176
81177         bool
81178         isDstOperand(int opIdx) override
81179         {
81180             switch (opIdx) {
81181               case 0: //vgpr_addr
81182                 return false;
81183               case 1: //vgpr_src
81184                 return false;
81185               case 2: //vgpr_dst
81186                 return true;
81187               default:
81188                 fatal("op idx %i out of bounds\n", opIdx);
81189                 return false;
81190             }
81191         } // isDstOperand
81192
81193         void execute(GPUDynInstPtr) override;
81194     }; // Inst_FLAT__FLAT_ATOMIC_UMIN_X2
81195
81196     class Inst_FLAT__FLAT_ATOMIC_SMAX_X2 : public Inst_FLAT
81197     {
81198       public:
81199         Inst_FLAT__FLAT_ATOMIC_SMAX_X2(InFmt_FLAT*);
81200         ~Inst_FLAT__FLAT_ATOMIC_SMAX_X2();
81201
81202         int
81203         getNumOperands() override
81204         {
81205             return numDstRegOperands() + numSrcRegOperands();
81206         } // getNumOperands
81207
81208         int numDstRegOperands() override { return 1; }
81209         int numSrcRegOperands() override { return 2; }
81210
81211         int
81212         getOperandSize(int opIdx) override
81213         {
81214             switch (opIdx) {
81215               case 0: //vgpr_addr
81216                 return 8;
81217               case 1: //vgpr_src
81218                 return 8;
81219               case 2: //vgpr_dst
81220                 return 8;
81221               default:
81222                 fatal("op idx %i out of bounds\n", opIdx);
81223                 return -1;
81224             }
81225         } // getOperandSize
81226
81227         bool
81228         isSrcOperand(int opIdx) override
81229         {
81230             switch (opIdx) {
81231               case 0: //vgpr_addr
81232                 return true;
81233               case 1: //vgpr_src
81234                 return true;
81235               case 2: //vgpr_dst
81236                 return false;
81237               default:
81238                 fatal("op idx %i out of bounds\n", opIdx);
81239                 return false;
81240             }
81241         } // isSrcOperand
81242
81243         bool
81244         isDstOperand(int opIdx) override
81245         {
81246             switch (opIdx) {
81247               case 0: //vgpr_addr
81248                 return false;
81249               case 1: //vgpr_src
81250                 return false;
81251               case 2: //vgpr_dst
81252                 return true;
81253               default:
81254                 fatal("op idx %i out of bounds\n", opIdx);
81255                 return false;
81256             }
81257         } // isDstOperand
81258
81259         void execute(GPUDynInstPtr) override;
81260     }; // Inst_FLAT__FLAT_ATOMIC_SMAX_X2
81261
81262     class Inst_FLAT__FLAT_ATOMIC_UMAX_X2 : public Inst_FLAT
81263     {
81264       public:
81265         Inst_FLAT__FLAT_ATOMIC_UMAX_X2(InFmt_FLAT*);
81266         ~Inst_FLAT__FLAT_ATOMIC_UMAX_X2();
81267
81268         int
81269         getNumOperands() override
81270         {
81271             return numDstRegOperands() + numSrcRegOperands();
81272         } // getNumOperands
81273
81274         int numDstRegOperands() override { return 1; }
81275         int numSrcRegOperands() override { return 2; }
81276
81277         int
81278         getOperandSize(int opIdx) override
81279         {
81280             switch (opIdx) {
81281               case 0: //vgpr_addr
81282                 return 8;
81283               case 1: //vgpr_src
81284                 return 8;
81285               case 2: //vgpr_dst
81286                 return 8;
81287               default:
81288                 fatal("op idx %i out of bounds\n", opIdx);
81289                 return -1;
81290             }
81291         } // getOperandSize
81292
81293         bool
81294         isSrcOperand(int opIdx) override
81295         {
81296             switch (opIdx) {
81297               case 0: //vgpr_addr
81298                 return true;
81299               case 1: //vgpr_src
81300                 return true;
81301               case 2: //vgpr_dst
81302                 return false;
81303               default:
81304                 fatal("op idx %i out of bounds\n", opIdx);
81305                 return false;
81306             }
81307         } // isSrcOperand
81308
81309         bool
81310         isDstOperand(int opIdx) override
81311         {
81312             switch (opIdx) {
81313               case 0: //vgpr_addr
81314                 return false;
81315               case 1: //vgpr_src
81316                 return false;
81317               case 2: //vgpr_dst
81318                 return true;
81319               default:
81320                 fatal("op idx %i out of bounds\n", opIdx);
81321                 return false;
81322             }
81323         } // isDstOperand
81324
81325         void execute(GPUDynInstPtr) override;
81326     }; // Inst_FLAT__FLAT_ATOMIC_UMAX_X2
81327
81328     class Inst_FLAT__FLAT_ATOMIC_AND_X2 : public Inst_FLAT
81329     {
81330       public:
81331         Inst_FLAT__FLAT_ATOMIC_AND_X2(InFmt_FLAT*);
81332         ~Inst_FLAT__FLAT_ATOMIC_AND_X2();
81333
81334         int
81335         getNumOperands() override
81336         {
81337             return numDstRegOperands() + numSrcRegOperands();
81338         } // getNumOperands
81339
81340         int numDstRegOperands() override { return 1; }
81341         int numSrcRegOperands() override { return 2; }
81342
81343         int
81344         getOperandSize(int opIdx) override
81345         {
81346             switch (opIdx) {
81347               case 0: //vgpr_addr
81348                 return 8;
81349               case 1: //vgpr_src
81350                 return 8;
81351               case 2: //vgpr_dst
81352                 return 8;
81353               default:
81354                 fatal("op idx %i out of bounds\n", opIdx);
81355                 return -1;
81356             }
81357         } // getOperandSize
81358
81359         bool
81360         isSrcOperand(int opIdx) override
81361         {
81362             switch (opIdx) {
81363               case 0: //vgpr_addr
81364                 return true;
81365               case 1: //vgpr_src
81366                 return true;
81367               case 2: //vgpr_dst
81368                 return false;
81369               default:
81370                 fatal("op idx %i out of bounds\n", opIdx);
81371                 return false;
81372             }
81373         } // isSrcOperand
81374
81375         bool
81376         isDstOperand(int opIdx) override
81377         {
81378             switch (opIdx) {
81379               case 0: //vgpr_addr
81380                 return false;
81381               case 1: //vgpr_src
81382                 return false;
81383               case 2: //vgpr_dst
81384                 return true;
81385               default:
81386                 fatal("op idx %i out of bounds\n", opIdx);
81387                 return false;
81388             }
81389         } // isDstOperand
81390
81391         void execute(GPUDynInstPtr) override;
81392     }; // Inst_FLAT__FLAT_ATOMIC_AND_X2
81393
81394     class Inst_FLAT__FLAT_ATOMIC_OR_X2 : public Inst_FLAT
81395     {
81396       public:
81397         Inst_FLAT__FLAT_ATOMIC_OR_X2(InFmt_FLAT*);
81398         ~Inst_FLAT__FLAT_ATOMIC_OR_X2();
81399
81400         int
81401         getNumOperands() override
81402         {
81403             return numDstRegOperands() + numSrcRegOperands();
81404         } // getNumOperands
81405
81406         int numDstRegOperands() override { return 1; }
81407         int numSrcRegOperands() override { return 2; }
81408
81409         int
81410         getOperandSize(int opIdx) override
81411         {
81412             switch (opIdx) {
81413               case 0: //vgpr_addr
81414                 return 8;
81415               case 1: //vgpr_src
81416                 return 8;
81417               case 2: //vgpr_dst
81418                 return 8;
81419               default:
81420                 fatal("op idx %i out of bounds\n", opIdx);
81421                 return -1;
81422             }
81423         } // getOperandSize
81424
81425         bool
81426         isSrcOperand(int opIdx) override
81427         {
81428             switch (opIdx) {
81429               case 0: //vgpr_addr
81430                 return true;
81431               case 1: //vgpr_src
81432                 return true;
81433               case 2: //vgpr_dst
81434                 return false;
81435               default:
81436                 fatal("op idx %i out of bounds\n", opIdx);
81437                 return false;
81438             }
81439         } // isSrcOperand
81440
81441         bool
81442         isDstOperand(int opIdx) override
81443         {
81444             switch (opIdx) {
81445               case 0: //vgpr_addr
81446                 return false;
81447               case 1: //vgpr_src
81448                 return false;
81449               case 2: //vgpr_dst
81450                 return true;
81451               default:
81452                 fatal("op idx %i out of bounds\n", opIdx);
81453                 return false;
81454             }
81455         } // isDstOperand
81456
81457         void execute(GPUDynInstPtr) override;
81458     }; // Inst_FLAT__FLAT_ATOMIC_OR_X2
81459
81460     class Inst_FLAT__FLAT_ATOMIC_XOR_X2 : public Inst_FLAT
81461     {
81462       public:
81463         Inst_FLAT__FLAT_ATOMIC_XOR_X2(InFmt_FLAT*);
81464         ~Inst_FLAT__FLAT_ATOMIC_XOR_X2();
81465
81466         int
81467         getNumOperands() override
81468         {
81469             return numDstRegOperands() + numSrcRegOperands();
81470         } // getNumOperands
81471
81472         int numDstRegOperands() override { return 1; }
81473         int numSrcRegOperands() override { return 2; }
81474
81475         int
81476         getOperandSize(int opIdx) override
81477         {
81478             switch (opIdx) {
81479               case 0: //vgpr_addr
81480                 return 8;
81481               case 1: //vgpr_src
81482                 return 8;
81483               case 2: //vgpr_dst
81484                 return 8;
81485               default:
81486                 fatal("op idx %i out of bounds\n", opIdx);
81487                 return -1;
81488             }
81489         } // getOperandSize
81490
81491         bool
81492         isSrcOperand(int opIdx) override
81493         {
81494             switch (opIdx) {
81495               case 0: //vgpr_addr
81496                 return true;
81497               case 1: //vgpr_src
81498                 return true;
81499               case 2: //vgpr_dst
81500                 return false;
81501               default:
81502                 fatal("op idx %i out of bounds\n", opIdx);
81503                 return false;
81504             }
81505         } // isSrcOperand
81506
81507         bool
81508         isDstOperand(int opIdx) override
81509         {
81510             switch (opIdx) {
81511               case 0: //vgpr_addr
81512                 return false;
81513               case 1: //vgpr_src
81514                 return false;
81515               case 2: //vgpr_dst
81516                 return true;
81517               default:
81518                 fatal("op idx %i out of bounds\n", opIdx);
81519                 return false;
81520             }
81521         } // isDstOperand
81522
81523         void execute(GPUDynInstPtr) override;
81524     }; // Inst_FLAT__FLAT_ATOMIC_XOR_X2
81525
81526     class Inst_FLAT__FLAT_ATOMIC_INC_X2 : public Inst_FLAT
81527     {
81528       public:
81529         Inst_FLAT__FLAT_ATOMIC_INC_X2(InFmt_FLAT*);
81530         ~Inst_FLAT__FLAT_ATOMIC_INC_X2();
81531
81532         int
81533         getNumOperands() override
81534         {
81535             return numDstRegOperands() + numSrcRegOperands();
81536         } // getNumOperands
81537
81538         int numDstRegOperands() override { return 1; }
81539         int numSrcRegOperands() override { return 2; }
81540
81541         int
81542         getOperandSize(int opIdx) override
81543         {
81544             switch (opIdx) {
81545               case 0: //vgpr_addr
81546                 return 8;
81547               case 1: //vgpr_src
81548                 return 8;
81549               case 2: //vgpr_dst
81550                 return 8;
81551               default:
81552                 fatal("op idx %i out of bounds\n", opIdx);
81553                 return -1;
81554             }
81555         } // getOperandSize
81556
81557         bool
81558         isSrcOperand(int opIdx) override
81559         {
81560             switch (opIdx) {
81561               case 0: //vgpr_addr
81562                 return true;
81563               case 1: //vgpr_src
81564                 return true;
81565               case 2: //vgpr_dst
81566                 return false;
81567               default:
81568                 fatal("op idx %i out of bounds\n", opIdx);
81569                 return false;
81570             }
81571         } // isSrcOperand
81572
81573         bool
81574         isDstOperand(int opIdx) override
81575         {
81576             switch (opIdx) {
81577               case 0: //vgpr_addr
81578                 return false;
81579               case 1: //vgpr_src
81580                 return false;
81581               case 2: //vgpr_dst
81582                 return true;
81583               default:
81584                 fatal("op idx %i out of bounds\n", opIdx);
81585                 return false;
81586             }
81587         } // isDstOperand
81588
81589         void execute(GPUDynInstPtr) override;
81590         void initiateAcc(GPUDynInstPtr) override;
81591         void completeAcc(GPUDynInstPtr) override;
81592     }; // Inst_FLAT__FLAT_ATOMIC_INC_X2
81593
81594     class Inst_FLAT__FLAT_ATOMIC_DEC_X2 : public Inst_FLAT
81595     {
81596       public:
81597         Inst_FLAT__FLAT_ATOMIC_DEC_X2(InFmt_FLAT*);
81598         ~Inst_FLAT__FLAT_ATOMIC_DEC_X2();
81599
81600         int
81601         getNumOperands() override
81602         {
81603             return numDstRegOperands() + numSrcRegOperands();
81604         } // getNumOperands
81605
81606         int numDstRegOperands() override { return 1; }
81607         int numSrcRegOperands() override { return 2; }
81608
81609         int
81610         getOperandSize(int opIdx) override
81611         {
81612             switch (opIdx) {
81613               case 0: //vgpr_addr
81614                 return 8;
81615               case 1: //vgpr_src
81616                 return 8;
81617               case 2: //vgpr_dst
81618                 return 8;
81619               default:
81620                 fatal("op idx %i out of bounds\n", opIdx);
81621                 return -1;
81622             }
81623         } // getOperandSize
81624
81625         bool
81626         isSrcOperand(int opIdx) override
81627         {
81628             switch (opIdx) {
81629               case 0: //vgpr_addr
81630                 return true;
81631               case 1: //vgpr_src
81632                 return true;
81633               case 2: //vgpr_dst
81634                 return false;
81635               default:
81636                 fatal("op idx %i out of bounds\n", opIdx);
81637                 return false;
81638             }
81639         } // isSrcOperand
81640
81641         bool
81642         isDstOperand(int opIdx) override
81643         {
81644             switch (opIdx) {
81645               case 0: //vgpr_addr
81646                 return false;
81647               case 1: //vgpr_src
81648                 return false;
81649               case 2: //vgpr_dst
81650                 return true;
81651               default:
81652                 fatal("op idx %i out of bounds\n", opIdx);
81653                 return false;
81654             }
81655         } // isDstOperand
81656
81657         void execute(GPUDynInstPtr) override;
81658         void initiateAcc(GPUDynInstPtr) override;
81659         void completeAcc(GPUDynInstPtr) override;
81660     }; // Inst_FLAT__FLAT_ATOMIC_DEC_X2
81661 } // namespace Gcn3ISA
81662
81663 #endif // __ARCH_GCN3_INSTS_INSTRUCTIONS_HH__