| /* |
| * Copyright (c) 2015-2021 Advanced Micro Devices, Inc. |
| * All rights reserved. |
| * |
| * For use for simulation and test purposes only |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are met: |
| * |
| * 1. Redistributions of source code must retain the above copyright notice, |
| * this list of conditions and the following disclaimer. |
| * |
| * 2. Redistributions in binary form must reproduce the above copyright notice, |
| * this list of conditions and the following disclaimer in the documentation |
| * and/or other materials provided with the distribution. |
| * |
| * 3. Neither the name of the copyright holder nor the names of its |
| * contributors may be used to endorse or promote products derived from this |
| * software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" |
| * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
| * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
| * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE |
| * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR |
| * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF |
| * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS |
| * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN |
| * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) |
| * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE |
| * POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #ifndef __ARCH_VEGA_INSTS_INSTRUCTIONS_HH__ |
| #define __ARCH_VEGA_INSTS_INSTRUCTIONS_HH__ |
| |
| #include "arch/amdgpu/vega/gpu_decoder.hh" |
| #include "arch/amdgpu/vega/insts/gpu_static_inst.hh" |
| #include "arch/amdgpu/vega/insts/op_encodings.hh" |
| #include "debug/VEGA.hh" |
| |
| namespace gem5 |
| { |
| |
| namespace VegaISA |
| { |
| class Inst_SOP2__S_ADD_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ADD_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ADD_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ADD_U32 |
| |
| class Inst_SOP2__S_SUB_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_SUB_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_SUB_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_SUB_U32 |
| |
| class Inst_SOP2__S_ADD_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ADD_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ADD_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ADD_I32 |
| |
| class Inst_SOP2__S_SUB_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_SUB_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_SUB_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_SUB_I32 |
| |
| class Inst_SOP2__S_ADDC_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ADDC_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ADDC_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ADDC_U32 |
| |
| class Inst_SOP2__S_SUBB_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_SUBB_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_SUBB_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_SUBB_U32 |
| |
| class Inst_SOP2__S_MIN_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_MIN_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_MIN_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_MIN_I32 |
| |
| class Inst_SOP2__S_MIN_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_MIN_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_MIN_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_MIN_U32 |
| |
| class Inst_SOP2__S_MAX_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_MAX_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_MAX_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_MAX_I32 |
| |
| class Inst_SOP2__S_MAX_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_MAX_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_MAX_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_MAX_U32 |
| |
| class Inst_SOP2__S_CSELECT_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_CSELECT_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_CSELECT_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_CSELECT_B32 |
| |
| class Inst_SOP2__S_CSELECT_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_CSELECT_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_CSELECT_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_CSELECT_B64 |
| |
| class Inst_SOP2__S_AND_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_AND_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_AND_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_AND_B32 |
| |
| class Inst_SOP2__S_AND_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_AND_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_AND_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_AND_B64 |
| |
| class Inst_SOP2__S_OR_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_OR_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_OR_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_OR_B32 |
| |
| class Inst_SOP2__S_OR_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_OR_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_OR_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_OR_B64 |
| |
| class Inst_SOP2__S_XOR_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_XOR_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_XOR_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_XOR_B32 |
| |
| class Inst_SOP2__S_XOR_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_XOR_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_XOR_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_XOR_B64 |
| |
| class Inst_SOP2__S_ANDN2_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ANDN2_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ANDN2_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ANDN2_B32 |
| |
| class Inst_SOP2__S_ANDN2_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ANDN2_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_ANDN2_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ANDN2_B64 |
| |
| class Inst_SOP2__S_ORN2_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ORN2_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ORN2_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ORN2_B32 |
| |
| class Inst_SOP2__S_ORN2_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ORN2_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_ORN2_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ORN2_B64 |
| |
| class Inst_SOP2__S_NAND_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_NAND_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_NAND_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_NAND_B32 |
| |
| class Inst_SOP2__S_NAND_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_NAND_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_NAND_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_NAND_B64 |
| |
| class Inst_SOP2__S_NOR_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_NOR_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_NOR_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_NOR_B32 |
| |
| class Inst_SOP2__S_NOR_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_NOR_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_NOR_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_NOR_B64 |
| |
| class Inst_SOP2__S_XNOR_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_XNOR_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_XNOR_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_XNOR_B32 |
| |
| class Inst_SOP2__S_XNOR_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_XNOR_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_XNOR_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_XNOR_B64 |
| |
| class Inst_SOP2__S_LSHL_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_LSHL_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_LSHL_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_LSHL_B32 |
| |
| class Inst_SOP2__S_LSHL_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_LSHL_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_LSHL_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_LSHL_B64 |
| |
| class Inst_SOP2__S_LSHR_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_LSHR_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_LSHR_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_LSHR_B32 |
| |
| class Inst_SOP2__S_LSHR_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_LSHR_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_LSHR_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_LSHR_B64 |
| |
| class Inst_SOP2__S_ASHR_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ASHR_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ASHR_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ASHR_I32 |
| |
| class Inst_SOP2__S_ASHR_I64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ASHR_I64(InFmt_SOP2*); |
| ~Inst_SOP2__S_ASHR_I64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ASHR_I64 |
| |
| class Inst_SOP2__S_BFM_B32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_BFM_B32(InFmt_SOP2*); |
| ~Inst_SOP2__S_BFM_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_BFM_B32 |
| |
| class Inst_SOP2__S_BFM_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_BFM_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_BFM_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_BFM_B64 |
| |
| class Inst_SOP2__S_MUL_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_MUL_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_MUL_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_MUL_I32 |
| |
| class Inst_SOP2__S_BFE_U32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_BFE_U32(InFmt_SOP2*); |
| ~Inst_SOP2__S_BFE_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_BFE_U32 |
| |
| class Inst_SOP2__S_BFE_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_BFE_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_BFE_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_BFE_I32 |
| |
| class Inst_SOP2__S_BFE_U64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_BFE_U64(InFmt_SOP2*); |
| ~Inst_SOP2__S_BFE_U64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_BFE_U64 |
| |
| class Inst_SOP2__S_BFE_I64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_BFE_I64(InFmt_SOP2*); |
| ~Inst_SOP2__S_BFE_I64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_BFE_I64 |
| |
| class Inst_SOP2__S_CBRANCH_G_FORK : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_CBRANCH_G_FORK(InFmt_SOP2*); |
| ~Inst_SOP2__S_CBRANCH_G_FORK(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 8; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_CBRANCH_G_FORK |
| |
| class Inst_SOP2__S_ABSDIFF_I32 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_ABSDIFF_I32(InFmt_SOP2*); |
| ~Inst_SOP2__S_ABSDIFF_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 4; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_ABSDIFF_I32 |
| |
| class Inst_SOP2__S_RFE_RESTORE_B64 : public Inst_SOP2 |
| { |
| public: |
| Inst_SOP2__S_RFE_RESTORE_B64(InFmt_SOP2*); |
| ~Inst_SOP2__S_RFE_RESTORE_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc_0 |
| return 8; |
| case 1: //ssrc_1 |
| return 4; |
| case 2: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP2__S_RFE_RESTORE_B64 |
| |
| class Inst_SOPK__S_MOVK_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_MOVK_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_MOVK_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //simm16 |
| return 2; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_MOVK_I32 |
| |
| class Inst_SOPK__S_CMOVK_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMOVK_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMOVK_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //simm16 |
| return 2; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMOVK_I32 |
| |
| class Inst_SOPK__S_CMPK_EQ_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_EQ_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_EQ_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_EQ_I32 |
| |
| class Inst_SOPK__S_CMPK_LG_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_LG_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_LG_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_LG_I32 |
| |
| class Inst_SOPK__S_CMPK_GT_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_GT_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_GT_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_GT_I32 |
| |
| class Inst_SOPK__S_CMPK_GE_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_GE_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_GE_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_GE_I32 |
| |
| class Inst_SOPK__S_CMPK_LT_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_LT_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_LT_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_LT_I32 |
| |
| class Inst_SOPK__S_CMPK_LE_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_LE_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_LE_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_LE_I32 |
| |
| class Inst_SOPK__S_CMPK_EQ_U32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_EQ_U32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_EQ_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_EQ_U32 |
| |
| class Inst_SOPK__S_CMPK_LG_U32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_LG_U32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_LG_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_LG_U32 |
| |
| class Inst_SOPK__S_CMPK_GT_U32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_GT_U32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_GT_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_GT_U32 |
| |
| class Inst_SOPK__S_CMPK_GE_U32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_GE_U32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_GE_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_GE_U32 |
| |
| class Inst_SOPK__S_CMPK_LT_U32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_LT_U32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_LT_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_LT_U32 |
| |
| class Inst_SOPK__S_CMPK_LE_U32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CMPK_LE_U32(InFmt_SOPK*); |
| ~Inst_SOPK__S_CMPK_LE_U32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CMPK_LE_U32 |
| |
| class Inst_SOPK__S_ADDK_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_ADDK_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_ADDK_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //simm16 |
| return 2; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_ADDK_I32 |
| |
| class Inst_SOPK__S_MULK_I32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_MULK_I32(InFmt_SOPK*); |
| ~Inst_SOPK__S_MULK_I32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //simm16 |
| return 2; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_MULK_I32 |
| |
| class Inst_SOPK__S_CBRANCH_I_FORK : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_CBRANCH_I_FORK(InFmt_SOPK*); |
| ~Inst_SOPK__S_CBRANCH_I_FORK(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 0; } |
| int numSrcRegOperands() override { return 2; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //sdst |
| return 8; |
| case 1: // |
| return 16; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_CBRANCH_I_FORK |
| |
| class Inst_SOPK__S_GETREG_B32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_GETREG_B32(InFmt_SOPK*); |
| ~Inst_SOPK__S_GETREG_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //simm16 |
| return 2; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_GETREG_B32 |
| |
| class Inst_SOPK__S_SETREG_B32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_SETREG_B32(InFmt_SOPK*); |
| ~Inst_SOPK__S_SETREG_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_SETREG_B32 |
| |
| class Inst_SOPK__S_SETREG_IMM32_B32 : public Inst_SOPK |
| { |
| public: |
| Inst_SOPK__S_SETREG_IMM32_B32(InFmt_SOPK*); |
| ~Inst_SOPK__S_SETREG_IMM32_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //simm32 |
| return 4; |
| case 1: //simm16 |
| return 2; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOPK__S_SETREG_IMM32_B32 |
| |
| class Inst_SOP1__S_MOV_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_MOV_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_MOV_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_MOV_B32 |
| |
| class Inst_SOP1__S_MOV_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_MOV_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_MOV_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_MOV_B64 |
| |
| class Inst_SOP1__S_CMOV_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_CMOV_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_CMOV_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_CMOV_B32 |
| |
| class Inst_SOP1__S_CMOV_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_CMOV_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_CMOV_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_CMOV_B64 |
| |
| class Inst_SOP1__S_NOT_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_NOT_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_NOT_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_NOT_B32 |
| |
| class Inst_SOP1__S_NOT_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_NOT_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_NOT_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_NOT_B64 |
| |
| class Inst_SOP1__S_WQM_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_WQM_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_WQM_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_WQM_B32 |
| |
| class Inst_SOP1__S_WQM_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_WQM_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_WQM_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_WQM_B64 |
| |
| class Inst_SOP1__S_BREV_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_BREV_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_BREV_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_BREV_B32 |
| |
| class Inst_SOP1__S_BREV_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_BREV_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_BREV_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 8; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_BREV_B64 |
| |
| class Inst_SOP1__S_BCNT0_I32_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_BCNT0_I32_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_BCNT0_I32_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_BCNT0_I32_B32 |
| |
| class Inst_SOP1__S_BCNT0_I32_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_BCNT0_I32_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_BCNT0_I32_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_BCNT0_I32_B64 |
| |
| class Inst_SOP1__S_BCNT1_I32_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_BCNT1_I32_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_BCNT1_I32_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_BCNT1_I32_B32 |
| |
| class Inst_SOP1__S_BCNT1_I32_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_BCNT1_I32_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_BCNT1_I32_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_BCNT1_I32_B64 |
| |
| class Inst_SOP1__S_FF0_I32_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_FF0_I32_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_FF0_I32_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_FF0_I32_B32 |
| |
| class Inst_SOP1__S_FF0_I32_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_FF0_I32_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_FF0_I32_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_FF0_I32_B64 |
| |
| class Inst_SOP1__S_FF1_I32_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_FF1_I32_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_FF1_I32_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_FF1_I32_B32 |
| |
| class Inst_SOP1__S_FF1_I32_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_FF1_I32_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_FF1_I32_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_FF1_I32_B64 |
| |
| class Inst_SOP1__S_FLBIT_I32_B32 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_FLBIT_I32_B32(InFmt_SOP1*); |
| ~Inst_SOP1__S_FLBIT_I32_B32(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 4; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_FLBIT_I32_B32 |
| |
| class Inst_SOP1__S_FLBIT_I32_B64 : public Inst_SOP1 |
| { |
| public: |
| Inst_SOP1__S_FLBIT_I32_B64(InFmt_SOP1*); |
| ~Inst_SOP1__S_FLBIT_I32_B64(); |
| |
| int |
| getNumOperands() override |
| { |
| return numDstRegOperands() + numSrcRegOperands(); |
| } // getNumOperands |
| |
| int numDstRegOperands() override { return 1; } |
| int numSrcRegOperands() override { return 1; } |
| |
| int |
| getOperandSize(int opIdx) override |
| { |
| switch (opIdx) { |
| case 0: //ssrc |
| return 8; |
| case 1: //sdst |
| return 4; |
| default: |
| fatal("op idx %i out of bounds\n", opIdx); |
| return -1; |
| } |
| } // getOperandSize |
| |
| void execute(GPUDynInstPtr) override; |
| }; // Inst_SOP1__S_FLBIT_I32_B64 |
| |
| class Inst_SOP1__S_FLBIT_I32 : |
