/*
 * Copyright (c) 2016-2017 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.
 *
 * Authors: Anthony Gutierrez
 */

#include "arch/gcn3/insts/op_encodings.hh"

#include <iomanip>

namespace Gcn3ISA
{
    // --- Inst_SOP2 base class methods ---

    Inst_SOP2::Inst_SOP2(InFmt_SOP2 *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Scalar);

        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
        } else {
            varSize = 4;
        } // if
    } // Inst_SOP2

    int
    Inst_SOP2::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_SOP2::hasSecondDword(InFmt_SOP2 *iFmt)
    {
        if (iFmt->SSRC0 == REG_SRC_LITERAL)
            return true;

        if (iFmt->SSRC1 == REG_SRC_LITERAL)
            return true;

        return false;
    }

    void
    Inst_SOP2::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        dis_stream << opSelectorToRegSym(instData.SDST) << ", ";

        if (instData.SSRC0 == REG_SRC_LITERAL) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << _srcLiteral << ", ";
        } else {
            dis_stream << opSelectorToRegSym(instData.SSRC0) << ", ";
        }

        if (instData.SSRC1 == REG_SRC_LITERAL) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << _srcLiteral;
        } else {
            dis_stream << opSelectorToRegSym(instData.SSRC1);
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_SOP2::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return isScalarReg(instData.SSRC0);
          case 1:
            return isScalarReg(instData.SSRC1);
          case 2:
            return isScalarReg(instData.SDST);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_SOP2::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOP2 instructions cannot access VGPRs
        return false;
    }

    int
    Inst_SOP2::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return opSelectorToRegIdx(instData.SSRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            return opSelectorToRegIdx(instData.SSRC1,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 2:
            return opSelectorToRegIdx(instData.SDST,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_SOPK base class methods ---

    Inst_SOPK::Inst_SOPK(InFmt_SOPK *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Scalar);

        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
        } else {
            varSize = 4;
        } // if
    } // Inst_SOPK

    Inst_SOPK::~Inst_SOPK()
    {
    } // ~Inst_SOPK

    int
    Inst_SOPK::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_SOPK::hasSecondDword(InFmt_SOPK *iFmt)
    {
        /*
          SOPK can be a 64-bit instruction, i.e., have a second dword:
          S_SETREG_IMM32_B32 writes some or all of the LSBs of a 32-bit
          literal constant into a hardware register;
          the way to detect such special case is to explicitly check the
          opcode (20/0x14)
        */
        if (iFmt->OP == 0x14)
            return true;

        return false;
    }


    void
    Inst_SOPK::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";

        // S_SETREG_IMM32_B32 is a 64-bit instruction, using a
        // 32-bit literal constant
        if (instData.OP == 0x14) {
            dis_stream << "0x" << std::hex << std::setfill('0')
                    << std::setw(8) << extData.imm_u32 << ", ";
        } else {
            dis_stream << opSelectorToRegSym(instData.SDST) << ", ";
        }

        dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(4)
                     << instData.SIMM16;

        disassembly = dis_stream.str();
    }

    bool
    Inst_SOPK::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
              return false;
          case 1:
              return isScalarReg(instData.SDST);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_SOPK::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOPK instruction cannot access VGPRs
        return false;
    }

    int
    Inst_SOPK::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return  -1;
          case 1:
            return opSelectorToRegIdx(instData.SDST,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_SOP1 base class methods ---

    Inst_SOP1::Inst_SOP1(InFmt_SOP1 *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Scalar);

        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
        } else {
            varSize = 4;
        } // if
    } // Inst_SOP1

    Inst_SOP1::~Inst_SOP1()
    {
    } // ~Inst_SOP1

    int
    Inst_SOP1::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_SOP1::hasSecondDword(InFmt_SOP1 *iFmt)
    {
        if (iFmt->SSRC0 == REG_SRC_LITERAL)
            return true;

        return false;
    }

    void
    Inst_SOP1::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        dis_stream << opSelectorToRegSym(instData.SDST) << ", ";

        if (instData.SSRC0 == REG_SRC_LITERAL) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << extData.imm_u32;
        } else {
            dis_stream << opSelectorToRegSym(instData.SSRC0);
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_SOP1::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            if (instData.OP == 0x1C) {
                // Special case for s_getpc, which has no source reg.
                // Instead, it implicitly reads the PC.
                return isScalarReg(instData.SDST);
            }
            return isScalarReg(instData.SSRC0);
          case 1:
              return isScalarReg(instData.SDST);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_SOP1::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOP1 instruction cannot access VGPRs
        return false;
    }

    int
    Inst_SOP1::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            if (instData.OP == 0x1C) {
                // Special case for s_getpc, which has no source reg.
                // Instead, it implicitly reads the PC.
                return opSelectorToRegIdx(instData.SDST,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            }
            return opSelectorToRegIdx(instData.SSRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            return opSelectorToRegIdx(instData.SDST,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_SOPC base class methods ---

    Inst_SOPC::Inst_SOPC(InFmt_SOPC *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Scalar);

        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
        } else {
            varSize = 4;
        } // if
    } // Inst_SOPC

    Inst_SOPC::~Inst_SOPC()
    {
    } // ~Inst_SOPC

    int
    Inst_SOPC::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_SOPC::hasSecondDword(InFmt_SOPC *iFmt)
    {
        if (iFmt->SSRC0 == REG_SRC_LITERAL)
            return true;

        if (iFmt->SSRC1 == REG_SRC_LITERAL)
            return true;

        return false;
    }

    void
    Inst_SOPC::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";

        if (instData.SSRC0 == REG_SRC_LITERAL) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << extData.imm_u32;
        } else {
            dis_stream << opSelectorToRegSym(instData.SSRC0) << ", ";
        }

        if (instData.SSRC1 == REG_SRC_LITERAL) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << extData.imm_u32;
        } else {
            dis_stream << opSelectorToRegSym(instData.SSRC1);
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_SOPC::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
              // SSRC0 is always a scalar reg or a constant
              return isScalarReg(instData.SSRC0);
          case 1:
              // SSRC1 is always a scalar reg or a constant
              return isScalarReg(instData.SSRC1);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_SOPC::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOPC instructions cannot access VGPRs
        return false;
    }

    int
    Inst_SOPC::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return opSelectorToRegIdx(instData.SSRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            return opSelectorToRegIdx(instData.SSRC1,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_SOPP base class methods ---

    Inst_SOPP::Inst_SOPP(InFmt_SOPP *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Scalar);

        // copy first instruction DWORD
        instData = iFmt[0];
    } // Inst_SOPP

    Inst_SOPP::~Inst_SOPP()
    {
    } // ~Inst_SOPP

    int
    Inst_SOPP::instSize() const
    {
        return 4;
    } // instSize

    void
    Inst_SOPP::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode;

        switch (instData.OP) {
          case 8:
            {
                dis_stream << " ";
                int dest = 4 * instData.SIMM16 + 4;
                dis_stream << "label_" << std::hex << dest;
            }
             break;
          case 12:
            {
                dis_stream << " ";

                int vm_cnt = 0;
                int exp_cnt = 0;
                int lgkm_cnt = 0;

                vm_cnt = bits<uint16_t>(instData.SIMM16, 3, 0);
                exp_cnt = bits<uint16_t>(instData.SIMM16, 6, 4);
                lgkm_cnt = bits<uint16_t>(instData.SIMM16, 11, 8);

                // if the counts are not maxed out, then we
                // print out the count value
                if (vm_cnt != 0xf) {
                    dis_stream << "vmcnt(" << vm_cnt << ")";
                }

                if (lgkm_cnt != 0xf) {
                    if (vm_cnt != 0xf)
                        dis_stream << " & ";

                    dis_stream << "lgkmcnt(" << lgkm_cnt << ")";
                }

                if (exp_cnt != 0x7) {
                    if (vm_cnt != 0xf || lgkm_cnt != 0xf)
                        dis_stream << " & ";

                    dis_stream << "expcnt(" << exp_cnt << ")";
                }
            }
            break;
          default:
            break;
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_SOPP::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOPP instructions have a maximum of 1 operand,
        // and it's always an immediate value
        return false;
    }

    bool
    Inst_SOPP::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOPP instructions have a maximum of 1 operand,
        // and it's always an immediate value
        return false;
    }

    int
    Inst_SOPP::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SOPP instructions have a maximum of 1 operand,
        // and it's always an immediate value
        return -1;
    }

    // --- Inst_SMEM base class methods ---

    Inst_SMEM::Inst_SMEM(InFmt_SMEM *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Scalar);
        setFlag(GlobalSegment);

        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_SMEM_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);

        if (instData.GLC)
            setFlag(GloballyCoherent);
    } // Inst_SMEM

    Inst_SMEM::~Inst_SMEM()
    {
    } // ~Inst_SMEM

    int
    Inst_SMEM::instSize() const
    {
        return 8;
    } // instSize

    void
    Inst_SMEM::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        if (numDstRegOperands()) {
            if (getOperandSize(getNumOperands() - 1) > 4) {
                dis_stream << "s[" << instData.SDATA << ":"
                    << instData.SDATA + getOperandSize(getNumOperands() - 1) /
                    4 - 1 << "], ";
            } else {
                dis_stream << "s" << instData.SDATA << ", ";
            }
        }

        // SBASE has an implied LSB of 0, so we need
        // to shift by one to get the actual value
        dis_stream << "s[" << (instData.SBASE << 1) << ":"
               << ((instData.SBASE << 1) + 1) << "], ";

        if (instData.IMM) {
            // IMM == 1 implies OFFSET should be
            // used as the offset
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(2)
                       << extData.OFFSET;
        } else {
            // IMM == 0 implies OFFSET should be
            // used to specify SGRP in which the
            // offset is held
            dis_stream << "s" << extData.OFFSET;
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_SMEM::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SBASE is always a scalar
            return true;
          case 1:
            if (instData.IMM) {
                return false;
            } else {
                return isScalarReg(extData.OFFSET);
            }
          case 2:
            return isScalarReg(instData.SDATA);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_SMEM::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // SMEM instructions cannot access VGPRs
        return false;
    }

    int
    Inst_SMEM::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SBASE has an implied LSB of 0, so we need
            // to shift by one to get the actual value
            return opSelectorToRegIdx(instData.SBASE << 1,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            if (instData.IMM) {
              // operand is an immediate value, not a register
              return -1;
            } else {
              return extData.OFFSET;
            }
          case 2:
            return opSelectorToRegIdx(instData.SDATA,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_VOP2 base class methods ---

    Inst_VOP2::Inst_VOP2(InFmt_VOP2 *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
            if (iFmt->SRC0 == REG_SRC_DPP) {
                setFlag(IsDPP);
            } else if (iFmt->SRC0 == REG_SRC_SWDA) {
                setFlag(IsSDWA);
            }
        } else {
            varSize = 4;
        } // if
    } // Inst_VOP2

    Inst_VOP2::~Inst_VOP2()
    {
    } // ~Inst_VOP2

    int
    Inst_VOP2::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_VOP2::hasSecondDword(InFmt_VOP2 *iFmt)
    {
        /*
          There are a few cases where VOP2 instructions have a second dword:

            1.  SRC0 is a literal
            2.  SRC0 is being used to add a data parallel primitive (DPP)
            operation to the instruction.
            3.  SRC0 is being used for sub d-word addressing (SDWA) of the
            operands in the instruction.
            4.  VOP2 instructions also have four special opcodes:',
            V_MADMK_{F16, F32} (0x24, 0x17), and V_MADAK_{F16, F32}',
            (0x25, 0x18), that are always 64b. the only way to',
            detect these special cases is to explicitly check,',
            the opcodes',
        */
        if (iFmt->SRC0 == REG_SRC_LITERAL || (iFmt->SRC0 == REG_SRC_DPP) ||
            (iFmt->SRC0 == REG_SRC_SWDA) || iFmt->OP == 0x17 ||
            iFmt->OP == 0x18 || iFmt->OP == 0x24 || iFmt->OP == 0x25)
            return true;

        return false;
    }

    void
    Inst_VOP2::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        dis_stream << "v" << instData.VDST << ", ";

        if (writesVCC())
            dis_stream << "vcc, ";

        if ((instData.SRC0 == REG_SRC_LITERAL) ||
            (instData.SRC0 == REG_SRC_DPP) ||
            (instData.SRC0 == REG_SRC_SWDA)) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << _srcLiteral << ", ";
        } else {
            dis_stream << opSelectorToRegSym(instData.SRC0) << ", ";
        }

        // VOP2 instructions have four special opcodes:',
        // V_MADMK_{F16, F32} (0x24, 0x17), and V_MADAK_{F16, F32}',
        // (0x25, 0x18), that are always 64b. the only way to',
        // detect these special cases is to explicitly check,',
        // the opcodes',
        if (instData.OP == 0x17 || instData.OP == 0x18 || instData.OP == 0x24
            || instData.OP == 0x25) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << extData.imm_u32 << ", ";
        }

        dis_stream << std::resetiosflags(std::ios_base::basefield) << "v"
            << instData.VSRC1;

        if (readsVCC())
            dis_stream << ", vcc";

        disassembly = dis_stream.str();
    }

    bool
    Inst_VOP2::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0 may be a scalar or vector register, an
            // inline constant, or a special HW register
            return isScalarReg(instData.SRC0);
          case 1:
            // instData.VSRC1 is never a scalar reg
            return false;
          case 2:
            if (readsVCC()) {
                return true;
            } else {
                // instData.VDST is never a scalar reg
                return false;
            }
          case 3:
            // if a VOP2 instruction has more than 3 ops
            // it must read from or write to VCC, and
            // VCC is always in an SGPR
            assert(readsVCC() || writesVCC());
            if (readsVCC()) {
                return false;
            } else {
                return true;
            }
          case 4:
            // if a VOP2 instruction has more than 4 ops
            // it must read from and write to VCC, and
            // VCC is always in an SGPR
            assert(writesVCC() && readsVCC());
            return true;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_VOP2::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0 may be a scalar or vector register, an
            // inline constant, or a special HW register
            return isVectorReg(instData.SRC0);
          case 1:
            // instData.VSRC1 is always a vector reg
            return true;
          case 2:
            if (readsVCC()) {
                return false;
            } else {
                // instData.VDST is always a vector reg
                return true;
            }
          case 3:
            // if a VOP2 instruction has more than 3 ops
            // it must read from or write to VCC, and
            // VCC is always in an SGPR
            assert(writesVCC() || readsVCC());
            if (readsVCC()) {
                return true;
            } else {
                return false;
            }
          case 4:
            // if a VOP2 instruction has more than 4 ops
            // it must read from and write to VCC, and
            // VCC is always in an SGPR
            assert(writesVCC() && readsVCC());
            return false;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    int
    Inst_VOP2::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return opSelectorToRegIdx(instData.SRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            return instData.VSRC1;
          case 2:
            if (readsVCC()) {
                return opSelectorToRegIdx(REG_VCC_LO,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            } else {
                return instData.VDST;
            }
          case 3:
            assert(writesVCC() || readsVCC());
            if (readsVCC()) {
                return instData.VDST;
            } else {
                return opSelectorToRegIdx(REG_VCC_LO,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            }
          case 4:
            assert(writesVCC() && readsVCC());
            return opSelectorToRegIdx(REG_VCC_LO,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_VOP1 base class methods ---

    Inst_VOP1::Inst_VOP1(InFmt_VOP1 *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
            if (iFmt->SRC0 == REG_SRC_DPP) {
                setFlag(IsDPP);
            } else if (iFmt->SRC0 == REG_SRC_SWDA) {
                setFlag(IsSDWA);
            }
        } else {
            varSize = 4;
        } // if
    } // Inst_VOP1

    Inst_VOP1::~Inst_VOP1()
    {
    } // ~Inst_VOP1

    int
    Inst_VOP1::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_VOP1::hasSecondDword(InFmt_VOP1 *iFmt)
    {
        /*
          There are several cases where VOP1 instructions have a second dword:

            1.  SRC0 is a literal.
            2.  SRC0 is being used to add a data parallel primitive (DPP)
            operation to the instruction.
            3.  SRC0 is being used for sub d-word addressing (SDWA) of the
            operands in the instruction.
        */
        if ((iFmt->SRC0 == REG_SRC_LITERAL) || (iFmt->SRC0 == REG_SRC_DPP) ||
            (iFmt->SRC0 == REG_SRC_SWDA))
            return true;

        return false;
    }

    void
    Inst_VOP1::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        dis_stream << "v" << instData.VDST << ", ";

        if ((instData.SRC0 == REG_SRC_LITERAL) ||
            (instData.SRC0 == REG_SRC_DPP) ||
            (instData.SRC0 == REG_SRC_SWDA)) {
            dis_stream << "0x" << std::hex << std::setfill('0') << std::setw(8)
                       << _srcLiteral;
        } else {
            dis_stream << opSelectorToRegSym(instData.SRC0);
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_VOP1::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
              return isScalarReg(instData.SRC0);
          case 1:
              // VDST is never a scalar reg
              return false;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_VOP1::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
              return isVectorReg(instData.SRC0);
          case 1:
              // VDST is always a vector reg
              return true;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    int
    Inst_VOP1::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return opSelectorToRegIdx(instData.SRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            return instData.VDST;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_VOPC base class methods ---

    Inst_VOPC::Inst_VOPC(InFmt_VOPC *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        if (hasSecondDword(iFmt)) {
            // copy second instruction DWORD into union
            extData = ((MachInst)iFmt)[1];
            _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
            varSize = 4 + 4;
            if (iFmt->SRC0 == REG_SRC_DPP) {
                setFlag(IsDPP);
            } else if (iFmt->SRC0 == REG_SRC_SWDA) {
                setFlag(IsSDWA);
            }
        } else {
            varSize = 4;
        } // if
    } // Inst_VOPC

    Inst_VOPC::~Inst_VOPC()
    {
    } // ~Inst_VOPC

    int
    Inst_VOPC::instSize() const
    {
        return varSize;
    } // instSize

    bool
    Inst_VOPC::hasSecondDword(InFmt_VOPC *iFmt)
    {
        /*
          There are several cases where VOPC instructions have a second dword:

            1.  SRC0 is a literal.
            2.  SRC0 is being used to add a data parallel primitive (DPP)
            operation to the instruction.
            3.  SRC0 is being used for sub d-word addressing (SDWA) of the
            operands in the instruction.
        */
        if ((iFmt->SRC0 == REG_SRC_LITERAL) || (iFmt->SRC0 == REG_SRC_DPP) ||
            (iFmt->SRC0 == REG_SRC_SWDA))
            return true;

        return false;
    }

    void
    Inst_VOPC::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " vcc, ";

        dis_stream << opSelectorToRegSym(instData.SRC0) << ", ";
        dis_stream << "v" << instData.VSRC1;

        disassembly = dis_stream.str();
    }

    bool
    Inst_VOPC::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return isScalarReg(instData.SRC0);
          case 1:
            // VSRC1 is never a scalar register
            return false;
          case 2:
            // VCC is always a scalar register
            return true;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_VOPC::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return isVectorReg(instData.SRC0);
          case 1:
            // VSRC1 is never a scalar register
            return true;
          case 2:
            // VCC is always a scalar register
            return false;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    int
    Inst_VOPC::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return opSelectorToRegIdx(instData.SRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            return instData.VSRC1;
          case 2:
            // VCC
            return opSelectorToRegIdx(REG_VCC_LO,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_VINTRP base class methods ---

    Inst_VINTRP::Inst_VINTRP(InFmt_VINTRP *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
    } // Inst_VINTRP

    Inst_VINTRP::~Inst_VINTRP()
    {
    } // ~Inst_VINTRP

    int
    Inst_VINTRP::instSize() const
    {
        return 4;
    } // instSize

    // --- Inst_VOP3 base class methods ---

    Inst_VOP3::Inst_VOP3(InFmt_VOP3 *iFmt, const std::string &opcode,
                         bool sgpr_dst)
        : GCN3GPUStaticInst(opcode), sgprDst(sgpr_dst)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_VOP3_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
    } // Inst_VOP3

    Inst_VOP3::~Inst_VOP3()
    {
    } // ~Inst_VOP3

    int
    Inst_VOP3::instSize() const
    {
        return 8;
    } // instSize

    void
    Inst_VOP3::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        int num_regs = 0;

        if (getOperandSize(getNumOperands() - 1) > 4) {
            num_regs = getOperandSize(getNumOperands() - 1) / 4;
            if (sgprDst)
                dis_stream << "s[";
            else
                dis_stream << "v[";
            dis_stream << instData.VDST << ":" << instData.VDST +
                          num_regs - 1 << "], ";
        } else {
            if (sgprDst)
                dis_stream << "s";
            else
                dis_stream << "v";
            dis_stream << instData.VDST << ", ";
        }

        num_regs = getOperandSize(0) / 4;

        if (extData.NEG & 0x1) {
            dis_stream << "-" << opSelectorToRegSym(extData.SRC0, num_regs);
        } else {
            dis_stream << opSelectorToRegSym(extData.SRC0, num_regs);
        }

        if (numSrcRegOperands() > 1) {
            num_regs = getOperandSize(1) / 4;

            if (extData.NEG & 0x2) {
                dis_stream << ", -"
                    << opSelectorToRegSym(extData.SRC1, num_regs);
            } else {
                dis_stream << ", "
                    << opSelectorToRegSym(extData.SRC1, num_regs);
            }
        }

        if (numSrcRegOperands() > 2) {
            num_regs = getOperandSize(2) / 4;

            if (extData.NEG & 0x4) {
                dis_stream << ", -"
                    << opSelectorToRegSym(extData.SRC2, num_regs);
            } else {
                dis_stream << ", "
                    << opSelectorToRegSym(extData.SRC2, num_regs);
            }
        }

        disassembly = dis_stream.str();
    }

    bool
    Inst_VOP3::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0 may be a scalar or vector register, an
            // inline constant, or a special HW register
            return isScalarReg(extData.SRC0);
          case 1:
            if (numSrcRegOperands() > 1) {
                // if we have more than 1 source operand then
                // op index 1 corresponds to SRC1. SRC1 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isScalarReg(extData.SRC1);
            } else {
                // if we only have 1 source operand, opIdx 1
                // will be VDST, and VDST is only a scalar
                // for v_cmp instructions
                if (sgprDst)
                    return true;
                return false;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                // if we have more than 2 source operand then
                // op index 2 corresponds to SRC2. SRC2 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isScalarReg(extData.SRC2);
            } else if (numSrcRegOperands() == 2) {
                // if we only have 2 source operands, opIdx 2
                // will be VDST, and VDST is only a scalar
                // for v_cmp instructions
                if (sgprDst)
                    return true;
                return false;
            } else {
                // if this idx doesn't correspond to SRCX or
                // VDST then it must be a VCC read or write,
                // and VCC is always stored in an SGPR pair
                assert(writesVCC() || readsVCC());
                return true;
            }
          case 3:
            if (numSrcRegOperands() == 3) {
                // if we have 3 source operands, opIdx 3
                // will be VDST, and VDST is only a scalar
                // for v_cmp instructions
                if (sgprDst)
                    return true;
                return false;
            } else {
                // if this idx doesn't correspond to VDST
                // then it must be a VCC read or write, and
                // and VCC is always stored in an SGPR pair
                assert(writesVCC() || readsVCC());
                return true;
            }
          case 4:
            // if a VOP3 instruction has more than 4 ops
            // it must read from and write to VCC, and
            // VCC is always in an SGPR
            assert(writesVCC() || readsVCC());
            return true;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_VOP3::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0 may be a scalar or vector register, an
            // inline constant, or a special HW register
            return isVectorReg(extData.SRC0);
          case 1:
            if (numSrcRegOperands() > 1) {
                // if we have more than 1 source operand then
                // op index 1 corresponds to SRC1. SRC1 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isVectorReg(extData.SRC1);
            } else {
                // if we only have 1 source operands, opIdx 1
                // will be VDST, and VDST is a scalar for v_cmp
                // instructions
                if (sgprDst)
                    return false;
                return true;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                // if we have more than 2 source operand then
                // op index 2 corresponds to SRC2. SRC2 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isVectorReg(extData.SRC2);
            } else if (numSrcRegOperands() == 2) {
                // if we only have 2 source operands, opIdx 2
                // will be VDST, and VDST is a scalar for v_cmp
                // instructions
                if (sgprDst)
                    return false;
                return true;
            } else {
                // if this idx doesn't correspond to SRCX or
                // VDST then it must be a VCC read or write,
                // and VCC is never stored in a VGPR
                assert(writesVCC() || readsVCC());
                return false;
            }
          case 3:
            if (numSrcRegOperands() == 3) {
                // if we have 3 source operands, opIdx 3
                // will be VDST, and VDST is a scalar for v_cmp
                // instructions
                if (sgprDst)
                    return false;
                return true;
            } else {
                // if this idx doesn't correspond to VDST
                // then it must be a VCC read or write, and
                // and VCC is never stored in a VGPR
                assert(writesVCC() || readsVCC());
                return false;
            }
          case 4:
            // if a VOP3 instruction has more than 4 ops
            // it must read from and write to VCC, and
            // VCC is never stored in a VGPR
            assert(writesVCC() || readsVCC());
            return false;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    int
    Inst_VOP3::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0
            return opSelectorToRegIdx(extData.SRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            if (numSrcRegOperands() > 1) {
                // if we have more than 1 source operand then
                // op index 1 corresponds to SRC1
                return opSelectorToRegIdx(extData.SRC1,
                    gpuDynInst->wavefront()->reservedScalarRegs);
            } else {
                // if we only have 1 source operand, opIdx 1
                // will be VDST
                if (sgprDst) {
                    return opSelectorToRegIdx(instData.VDST,
                            gpuDynInst->wavefront()->reservedScalarRegs);
                }
                return instData.VDST;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                // if we have more than 2 source operand then
                // op index 2 corresponds to SRC2. SRC2 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return opSelectorToRegIdx(extData.SRC2,
                    gpuDynInst->wavefront()->reservedScalarRegs);
            } else if (numSrcRegOperands() == 2) {
                // if we only have 2 source operands, opIdx 2
                // will be VDST, and VDST is always a vector
                // reg
                if (sgprDst) {
                    return opSelectorToRegIdx(instData.VDST,
                            gpuDynInst->wavefront()->reservedScalarRegs);
                }
                return instData.VDST;
            } else {
                // if this idx doesn't correspond to SRCX or
                // VDST then it must be a VCC read or write,
                // and VCC is never stored in a VGPR
                assert(writesVCC() || readsVCC());
                return opSelectorToRegIdx(REG_VCC_LO,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            }
          case 3:
            if (numSrcRegOperands() == 3) {
                // if we have 3 source operands then op
                // idx 3 will correspond to VDST
                if (sgprDst) {
                    return opSelectorToRegIdx(instData.VDST,
                            gpuDynInst->wavefront()->reservedScalarRegs);
                }
                return instData.VDST;
            } else {
                // if this idx doesn't correspond to VDST
                // then it must be a VCC read or write
                assert(writesVCC() || readsVCC());
                return opSelectorToRegIdx(REG_VCC_LO,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            }
          case 4:
            // if a VOP3 instruction has more than 4 ops
            // it must read from and write to VCC
            assert(writesVCC() || readsVCC());
            return opSelectorToRegIdx(REG_VCC_LO,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_VOP3_SDST_ENC base class methods ---

    Inst_VOP3_SDST_ENC::Inst_VOP3_SDST_ENC(InFmt_VOP3_SDST_ENC *iFmt,
                                           const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_VOP3_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
    } // Inst_VOP3_SDST_ENC

    Inst_VOP3_SDST_ENC::~Inst_VOP3_SDST_ENC()
    {
    } // ~Inst_VOP3_SDST_ENC

    int
    Inst_VOP3_SDST_ENC::instSize() const
    {
        return 8;
    } // instSize

    void
    Inst_VOP3_SDST_ENC::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";

        dis_stream << "v" << instData.VDST << ", ";

        if (numDstRegOperands() == 2) {
            if (getOperandSize(getNumOperands() - 1) > 4) {
                int num_regs = getOperandSize(getNumOperands() - 1) / 4;
                dis_stream << opSelectorToRegSym(instData.SDST, num_regs)
                    << ", ";
            } else {
                dis_stream << opSelectorToRegSym(instData.SDST) << ", ";
            }
        }

        if (extData.NEG & 0x1) {
            dis_stream << "-" << opSelectorToRegSym(extData.SRC0) << ", ";
        } else {
            dis_stream << opSelectorToRegSym(extData.SRC0) << ", ";
        }

        if (extData.NEG & 0x2) {
            dis_stream << "-" << opSelectorToRegSym(extData.SRC1);
        } else {
            dis_stream << opSelectorToRegSym(extData.SRC1);
        }

        if (numSrcRegOperands() == 3) {
            if (extData.NEG & 0x4) {
                dis_stream << ", -" << opSelectorToRegSym(extData.SRC2);
            } else {
                dis_stream << ", " << opSelectorToRegSym(extData.SRC2);
            }
        }

        if (readsVCC())
            dis_stream << ", vcc";

        disassembly = dis_stream.str();
    }

    bool
    Inst_VOP3_SDST_ENC::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0 may be a scalar or vector register, an
            // inline constant, or a special HW register
            return isScalarReg(extData.SRC0);
          case 1:
            if (numSrcRegOperands() > 1) {
                // if we have more than 1 source operand then
                // op index 1 corresponds to SRC1. SRC1 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isScalarReg(extData.SRC1);
            } else {
                // if we only have 1 source operand, opIdx 1
                // will be VDST, and VDST is never a scalar
                // reg
                if (instData.VDST == REG_VCC_LO)
                    return true;
                return false;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                // if we have more than 2 source operand then
                // op index 2 corresponds to SRC2. SRC2 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isScalarReg(extData.SRC2);
            } else if (numSrcRegOperands() == 2) {
                // if we only have 2 source operands, opIdx 2
                // will be VDST, and VDST is never a scalar
                // reg
                if (instData.VDST == REG_VCC_LO)
                    return true;
                return false;
            } else {
                // if this idx doesn't correspond to SRCX or
                // VDST then it must be a VCC read or write,
                // and VCC is always stored in an SGPR pair
                assert(writesVCC() || readsVCC());
                return true;
            }
          case 3:
            if (numSrcRegOperands() == 3) {
                // if we have 3 source operands then op
                // idx 3 will correspond to VDST, and VDST
                // is never a scalar reg
                if (instData.VDST == REG_VCC_LO)
                    return true;
                return false;
            } else {
                // if this idx doesn't correspond to VDST
                // then it must be a VCC read or write, and
                // and VCC is always stored in an SGPR pair
                assert(writesVCC() || readsVCC());
                return true;
            }
          case 4:
            // if a VOP3 instruction has more than 4 ops
            // it must read from and write to VCC, and
            // VCC is always in an SGPR
            assert(writesVCC() || readsVCC());
            return true;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_VOP3_SDST_ENC::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0 may be a scalar or vector register, an
            // inline constant, or a special HW register
            return isVectorReg(extData.SRC0);
          case 1:
            if (numSrcRegOperands() > 1) {
                // if we have more than 1 source operand then
                // op index 1 corresponds to SRC1. SRC1 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isVectorReg(extData.SRC1);
            } else {
                // if we only have 1 source operand, opIdx 1
                // will be VDST, and VDST is always a vector
                // reg
                if (instData.VDST == REG_VCC_LO)
                    return false;
                return true;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                // if we have more than 2 source operand then
                // op index 2 corresponds to SRC2. SRC2 may be
                // a scalar or vector register, an inline
                // constant, or a special HW register
                return isVectorReg(extData.SRC2);
            } else if (numSrcRegOperands() == 2) {
                // if we only have 2 source operands, opIdx 2
                // will be VDST, and VDST is always a vector
                // reg
                if (instData.VDST == REG_VCC_LO)
                    return false;
                return true;
            } else {
                // if this idx doesn't correspond to SRCX or
                // VDST then it must be a VCC read or write,
                // and VCC is never stored in a VGPR
                assert(writesVCC() || readsVCC());
                return false;
            }
          case 3:
            if (numSrcRegOperands() == 3) {
                // if we have 3 source operands then op
                // idx 3 will correspond to VDST, and VDST
                // is always a vector reg
                if (instData.VDST == REG_VCC_LO)
                    return false;
                return true;
            } else {
                // if this idx doesn't correspond to VDST
                // then it must be a VCC read or write, and
                // and VCC is never stored in a VGPR
                assert(writesVCC() || readsVCC());
                return false;
            }
          case 4:
            // if a VOP3 instruction has more than 4 ops
            // it must read from and write to VCC, and
            // VCC is never stored in a VGPR
            assert(writesVCC() || readsVCC());
            return false;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    int
    Inst_VOP3_SDST_ENC::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            // SRC0
            return opSelectorToRegIdx(extData.SRC0,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          case 1:
            if (numSrcRegOperands() > 1) {
                // if we have more than 1 source operand then
                // op index 1 corresponds to SRC1
                return opSelectorToRegIdx(extData.SRC1,
                    gpuDynInst->wavefront()->reservedScalarRegs);
            } else {
                // if we only have 1 source operand, opIdx 1
                // will be VDST
                return instData.VDST;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                // if we have more than 2 source operand then
                // op index 2 corresponds to SRC2
                return opSelectorToRegIdx(extData.SRC2,
                    gpuDynInst->wavefront()->reservedScalarRegs);
            } else if (numSrcRegOperands() == 2) {
                // if we only have 2 source operands, opIdx 2
                // will be VDST
                return instData.VDST;
            } else {
                // if this idx doesn't correspond to SRCX or
                // VDST then it must be a VCC read or write
                assert(writesVCC() || readsVCC());
                return opSelectorToRegIdx(instData.SDST,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            }
          case 3:
            if (numSrcRegOperands() == 3) {
                // if we have 3 source operands then op
                // idx 3 will correspond to VDST
                return instData.VDST;
            } else {
                // if this idx doesn't correspond to VDST
                // then it must be a VCC read or write
                assert(writesVCC() || readsVCC());
                return opSelectorToRegIdx(instData.SDST,
                        gpuDynInst->wavefront()->reservedScalarRegs);
            }
          case 4:
            // if a VOP3 instruction has more than 4 ops
            // it must read from and write to VCC
            assert(writesVCC() || readsVCC());
            return opSelectorToRegIdx(instData.SDST,
                    gpuDynInst->wavefront()->reservedScalarRegs);
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_DS base class methods ---

    Inst_DS::Inst_DS(InFmt_DS *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(GroupSegment);

        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_DS_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
    } // Inst_DS

    Inst_DS::~Inst_DS()
    {
    } // ~Inst_DS

    int
    Inst_DS::instSize() const
    {
        return 8;
    } // instSize

    void
    Inst_DS::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";

        if (numDstRegOperands())
            dis_stream << "v" << extData.VDST << ", ";

        dis_stream << "v" << extData.ADDR;

        if (numSrcRegOperands() > 1)
            dis_stream << ", v" << extData.DATA0;

        if (numSrcRegOperands() > 2)
            dis_stream << ", v" << extData.DATA1;

        uint16_t offset = 0;

        if (instData.OFFSET1) {
            offset += instData.OFFSET1;
            offset <<= 8;
        }

        if (instData.OFFSET0)
            offset += instData.OFFSET0;

        if (offset)
            dis_stream << " offset:" << offset;

        disassembly = dis_stream.str();
    }

    bool
    Inst_DS::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // DS instructions cannot access SGPRs
        return false;
    }

    bool
    Inst_DS::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // DS instructions only access VGPRs
        return true;
    }

    int
    Inst_DS::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return extData.ADDR;
          case 1:
            if (numSrcRegOperands() > 1) {
                return extData.DATA0;
            } else if (numDstRegOperands()) {
                return extData.VDST;
            }
          case 2:
            if (numSrcRegOperands() > 2) {
                return extData.DATA1;
            } else if (numDstRegOperands()) {
                return extData.VDST;
            }
          case 3:
            assert(numDstRegOperands());
            return extData.VDST;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_MUBUF base class methods ---

    Inst_MUBUF::Inst_MUBUF(InFmt_MUBUF *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_MUBUF_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);

        if (instData.GLC)
            setFlag(GloballyCoherent);

        if (instData.SLC)
            setFlag(SystemCoherent);
    } // Inst_MUBUF

    Inst_MUBUF::~Inst_MUBUF()
    {
    } // ~Inst_MUBUF

    int
    Inst_MUBUF::instSize() const
    {
        return 8;
    } // instSize

    void
    Inst_MUBUF::generateDisassembly()
    {
        // SRSRC is always in units of 4 SGPRs
        int srsrc_val = extData.SRSRC * 4;
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";
        dis_stream << "v" << extData.VDATA << ", v" << extData.VADDR << ", ";
        dis_stream << "s[" << srsrc_val << ":"
                   << srsrc_val + 3 << "], ";
        dis_stream << "s" << extData.SOFFSET;

        if (instData.OFFSET)
            dis_stream << ", offset:" << instData.OFFSET;

        disassembly = dis_stream.str();
    }

    bool
    Inst_MUBUF::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return false;
          case 1:
            return true;
          case 2:
            return true;
          case 3:
            return false;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    bool
    Inst_MUBUF::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return true;
          case 1:
            return false;
          case 2:
            return false;
          case 3:
            return true;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return false;
        }
    }

    int
    Inst_MUBUF::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
              return extData.VADDR;
          case 1:
              // SRSRC is always in units of 4 SGPRs
              return extData.SRSRC * 4;
          case 2:
              return extData.SOFFSET;
          case 3:
            return extData.VDATA;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }

    // --- Inst_MTBUF base class methods ---

    Inst_MTBUF::Inst_MTBUF(InFmt_MTBUF *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_MTBUF_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);

        if (instData.GLC)
            setFlag(GloballyCoherent);

        if (extData.SLC)
            setFlag(SystemCoherent);

    } // Inst_MTBUF

    Inst_MTBUF::~Inst_MTBUF()
    {
    } // ~Inst_MTBUF

    int
    Inst_MTBUF::instSize() const
    {
        return 8;
    } // instSize

    // --- Inst_MIMG base class methods ---

    Inst_MIMG::Inst_MIMG(InFmt_MIMG *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_MIMG_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);

        if (instData.GLC)
            setFlag(GloballyCoherent);

        if (instData.SLC)
            setFlag(SystemCoherent);
    } // Inst_MIMG

    Inst_MIMG::~Inst_MIMG()
    {
    } // ~Inst_MIMG

    int
    Inst_MIMG::instSize() const
    {
        return 8;
    } // instSize

    // --- Inst_EXP base class methods ---

    Inst_EXP::Inst_EXP(InFmt_EXP *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_EXP_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);
    } // Inst_EXP

    Inst_EXP::~Inst_EXP()
    {
    } // ~Inst_EXP

    int
    Inst_EXP::instSize() const
    {
        return 8;
    } // instSize

    // --- Inst_FLAT base class methods ---

    Inst_FLAT::Inst_FLAT(InFmt_FLAT *iFmt, const std::string &opcode)
        : GCN3GPUStaticInst(opcode)
    {
        setFlag(Flat);
        // copy first instruction DWORD
        instData = iFmt[0];
        // copy second instruction DWORD
        extData = ((InFmt_FLAT_1 *)iFmt)[1];
        _srcLiteral = *reinterpret_cast<uint32_t*>(&iFmt[1]);

        if (instData.GLC)
            setFlag(GloballyCoherent);

        if (instData.SLC)
            setFlag(SystemCoherent);
    } // Inst_FLAT

    Inst_FLAT::~Inst_FLAT()
    {
    } // ~Inst_FLAT

    int
    Inst_FLAT::instSize() const
    {
        return 8;
    } // instSize

    void
    Inst_FLAT::generateDisassembly()
    {
        std::stringstream dis_stream;
        dis_stream << _opcode << " ";

        if (isLoad())
            dis_stream << "v" << extData.VDST << ", ";

        dis_stream << "v[" << extData.ADDR << ":" << extData.ADDR + 1 << "]";

        if (isStore())
            dis_stream << ", v" << extData.DATA;

        disassembly = dis_stream.str();
    }

    bool
    Inst_FLAT::isScalarRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // if a FLAT instruction has more than two
        // operands it must be an atomic
        if (opIdx == 2)
            assert(isAtomic());

        // FLAT instructions cannot access SGPRs
        return false;
    }

    bool
    Inst_FLAT::isVectorRegister(int opIdx)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        // if a FLAT instruction has more than two
        // operands it must be an atomic
        if (opIdx == 2)
            assert(isAtomic());

        // FLAT instructions only access VGPRs
        return true;
    }

    int
    Inst_FLAT::getRegisterIndex(int opIdx, GPUDynInstPtr gpuDynInst)
    {
        assert(opIdx >= 0);
        assert(opIdx < getNumOperands());

        switch (opIdx) {
          case 0:
            return extData.ADDR;
          case 1:
            if (isStore()) {
                return extData.DATA;
            } else if (isLoad()) {
                return extData.VDST;
            } else if (isAtomic()) {
                // For flat_atomic instructions,
                // the DATA VGPR gives the source
                return extData.DATA;
            } else {
                fatal("Unsupported flat instr type\n");
            }
          case 2:
             // if a FLAT instruction has more than two
             // operands it must be an atomic
            assert(isAtomic());
            return extData.VDST;
          default:
            fatal("Operand at idx %i does not exist\n", opIdx);
            return -1;
        }
    }
} // namespace Gcn3ISA