sve.hh

Go to the documentation of this file.

/*
 * Copyright (c) 2017-2019 ARM Limited
 * All rights reserved
 *
 * The license below extends only to copyright in the software and shall
 * not be construed as granting a license to any other intellectual
 * property including but not limited to intellectual property relating
 * to a hardware implementation of the functionality of the software
 * licensed hereunder.  You may use the software subject to the license
 * terms below provided that you ensure that this notice is replicated
 * unmodified and in its entirety in all distributions of the software,
 * modified or unmodified, in source code or in binary form.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are
 * met: redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer;
 * 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;
 * neither the name of the copyright holders 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
 * OWNER 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: Giacomo Gabrielli
 */

#ifndef __ARCH_ARM_INSTS_SVE_HH__
#define __ARCH_ARM_INSTS_SVE_HH__

#include "arch/arm/insts/static_inst.hh"

namespace ArmISA {

enum class SvePredType {
    NONE,
    MERGE,
    ZERO,
    SELECT
};

const char* svePredTypeToStr(SvePredType pt);

class SveIndexIIOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    int8_t imm1;
    int8_t imm2;

    SveIndexIIOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest,
            int8_t _imm1, int8_t _imm2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), imm1(_imm1), imm2(_imm2)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveIndexIROp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    int8_t imm1;
    IntRegIndex op2;

    SveIndexIROp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest,
            int8_t _imm1, IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
          dest(_dest), imm1(_imm1), op2(_op2)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveIndexRIOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    int8_t imm2;

    SveIndexRIOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest,
            IntRegIndex _op1, int8_t _imm2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), imm2(_imm2)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveIndexRROp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    IntRegIndex op2;

    SveIndexRROp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest,
            IntRegIndex _op1, IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

// Predicate count SVE instruction.
class SvePredCountOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex gp;
    bool srcIs32b;
    bool destIsVec;

    SvePredCountOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _gp,
            bool _srcIs32b = false, bool _destIsVec = false) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), gp(_gp),
        srcIs32b(_srcIs32b), destIsVec(_destIsVec)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

// Predicate count SVE instruction (predicated).
class SvePredCountPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    IntRegIndex gp;

    SvePredCountPredOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), gp(_gp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveWhileOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;
    bool srcIs32b;

    SveWhileOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
               IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _op2,
               bool _srcIs32b) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), srcIs32b(_srcIs32b)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveCompTermOp : public ArmStaticInst {
  protected:
    IntRegIndex op1, op2;

    SveCompTermOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                  IntRegIndex _op1, IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        op1(_op1), op2(_op2)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnaryPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, gp;

    SveUnaryPredOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                   IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), gp(_gp)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnaryUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1;

    SveUnaryUnpredOp(const char* mnem, ExtMachInst _machInst,
                     OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnaryWideImmUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    uint64_t imm;

    SveUnaryWideImmUnpredOp(const char* mnem, ExtMachInst _machInst,
                            OpClass __opClass, IntRegIndex _dest,
                            uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnaryWideImmPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    uint64_t imm;
    IntRegIndex gp;

    bool isMerging;

    SveUnaryWideImmPredOp(const char* mnem, ExtMachInst _machInst,
                          OpClass __opClass, IntRegIndex _dest,
                          uint64_t _imm, IntRegIndex _gp, bool _isMerging) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), imm(_imm), gp(_gp), isMerging(_isMerging)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinImmUnpredConstrOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1;
    uint64_t imm;

    SveBinImmUnpredConstrOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinImmPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, gp;
    uint64_t imm;

    SveBinImmPredOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                    IntRegIndex _dest, uint64_t _imm, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), gp(_gp), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinWideImmUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    uint64_t imm;

    SveBinWideImmUnpredOp(const char* mnem, ExtMachInst _machInst,
                          OpClass __opClass, IntRegIndex _dest,
                          uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinDestrPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op2, gp;

    SveBinDestrPredOp(const char* mnem, ExtMachInst _machInst,
                      OpClass __opClass, IntRegIndex _dest, IntRegIndex _op2,
                      IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op2(_op2), gp(_gp)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinConstrPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2, gp;
    SvePredType predType;

    SveBinConstrPredOp(const char* mnem, ExtMachInst _machInst,
                       OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
                       IntRegIndex _op2, IntRegIndex _gp,
                       SvePredType _predType) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), gp(_gp), predType(_predType)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;

    SveBinUnpredOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                   IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinIdxUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;
    uint8_t index;

    SveBinIdxUnpredOp(const char* mnem, ExtMachInst _machInst,
                      OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
                      IntRegIndex _op2, uint8_t _index) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), index(_index)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePredLogicalOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2, gp;
    bool isSel;

    SvePredLogicalOp(const char* mnem, ExtMachInst _machInst,
                     OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
                     IntRegIndex _op2, IntRegIndex _gp, bool _isSel = false) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), gp(_gp), isSel(_isSel)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePredBinPermOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;

    SvePredBinPermOp(const char* mnem, ExtMachInst _machInst,
                     OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
                     IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveCmpOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, gp, op1, op2;

    SveCmpOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
             IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _op2,
             IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), gp(_gp), op1(_op1), op2(_op2)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveCmpImmOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, gp, op1;
    uint64_t imm;

    SveCmpImmOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                IntRegIndex _dest, IntRegIndex _op1, uint64_t _imm,
                IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), gp(_gp), op1(_op1), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveTerPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2, gp;

    SveTerPredOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                 IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _op2,
                 IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), gp(_gp)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveTerImmUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op2;
    uint64_t imm;

    SveTerImmUnpredOp(const char* mnem, ExtMachInst _machInst,
                      OpClass __opClass, IntRegIndex _dest, IntRegIndex _op2,
                      uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op2(_op2), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveReducOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, gp;

    SveReducOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
               IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), gp(_gp)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveOrdReducOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, gp;

    SveOrdReducOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
               IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), gp(_gp)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePtrueOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    uint8_t imm;

    SvePtrueOp(const char* mnem, ExtMachInst _machInst,
               OpClass __opClass, IntRegIndex _dest, uint8_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveIntCmpOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1, op2;
    IntRegIndex gp;
    bool op2IsWide;

    SveIntCmpOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                  IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _op2,
                  IntRegIndex _gp, bool _op2IsWide = false) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), gp(_gp), op2IsWide(_op2IsWide)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveIntCmpImmOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    int64_t imm;
    IntRegIndex gp;

    SveIntCmpImmOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                  IntRegIndex _dest, IntRegIndex _op1, int64_t _imm,
                  IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), imm(_imm), gp(_gp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveAdrOp : public ArmStaticInst {
  public:
   enum SveAdrOffsetFormat {
       SveAdrOffsetPacked,
       SveAdrOffsetUnpackedSigned,
       SveAdrOffsetUnpackedUnsigned
   };

  protected:
    IntRegIndex dest, op1, op2;
    uint8_t mult;
    SveAdrOffsetFormat offsetFormat;

    SveAdrOp(const char* mnem, ExtMachInst _machInst,
             OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
             IntRegIndex _op2, uint8_t _mult,
             SveAdrOffsetFormat _offsetFormat) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), mult(_mult),
        offsetFormat(_offsetFormat)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveElemCountOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    uint8_t pattern;
    uint8_t imm;
    bool dstIsVec;
    bool dstIs32b;
    uint8_t esize;

    SveElemCountOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                  IntRegIndex _dest, uint8_t _pattern, uint8_t _imm,
                  bool _dstIsVec, bool _dstIs32b) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), pattern(_pattern), imm(_imm), dstIsVec(_dstIsVec),
        dstIs32b(_dstIs32b)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePartBrkOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex gp;
    IntRegIndex op1;
    bool isMerging;

    SvePartBrkOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                  IntRegIndex _dest, IntRegIndex _gp, IntRegIndex _op1,
                  bool _isMerging) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), gp(_gp), op1(_op1), isMerging(_isMerging)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePartBrkPropOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    IntRegIndex op2;
    IntRegIndex gp;

    SvePartBrkPropOp(const char* mnem, ExtMachInst _machInst,
                     OpClass __opClass, IntRegIndex _dest,
                     IntRegIndex _op1, IntRegIndex _op2, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), gp(_gp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveSelectOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    IntRegIndex gp;
    bool conditional;
    bool scalar;
    bool simdFp;
    size_t scalar_width;

    SveSelectOp(const char* mnem, ExtMachInst _machInst,
                      OpClass __opClass, IntRegIndex _dest,
                      IntRegIndex _op1, IntRegIndex _gp,
                      bool _conditional, bool _scalar,
                      bool _simdFp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), gp(_gp), conditional(_conditional),
        scalar(_scalar), simdFp(_simdFp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnaryPredPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    IntRegIndex gp;

    SveUnaryPredPredOp(const char* mnem, ExtMachInst _machInst,
                       OpClass __opClass, IntRegIndex _dest,
                       IntRegIndex _op1, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), gp(_gp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveTblOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    IntRegIndex op2;

    SveTblOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
            IntRegIndex _dest, IntRegIndex _op1, IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnpackOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;

    SveUnpackOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                IntRegIndex _dest, IntRegIndex _op1) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePredTestOp : public ArmStaticInst {
  protected:
    IntRegIndex op1;
    IntRegIndex gp;

    SvePredTestOp(const char* mnem, ExtMachInst _machInst, OpClass __opClass,
                IntRegIndex _op1, IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        op1(_op1), gp(_gp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePredUnaryWImplicitSrcOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;

    SvePredUnaryWImplicitSrcOp(const char* mnem, ExtMachInst _machInst,
                               OpClass __opClass, IntRegIndex _dest) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePredUnaryWImplicitSrcPredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex gp;

    SvePredUnaryWImplicitSrcPredOp(const char* mnem, ExtMachInst _machInst,
                                   OpClass __opClass, IntRegIndex _dest,
                                   IntRegIndex _gp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), gp(_gp)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SvePredUnaryWImplicitDstOp : public ArmStaticInst {
  protected:
    IntRegIndex op1;

    SvePredUnaryWImplicitDstOp(const char* mnem, ExtMachInst _machInst,
                               OpClass __opClass, IntRegIndex _op1) :
        ArmStaticInst(mnem, _machInst, __opClass),
        op1(_op1)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveWImplicitSrcDstOp : public ArmStaticInst {
  protected:
    SveWImplicitSrcDstOp(const char* mnem, ExtMachInst _machInst,
                         OpClass __opClass) :
        ArmStaticInst(mnem, _machInst, __opClass)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinImmUnpredDestrOp : public ArmStaticInst {
  protected:
    IntRegIndex dest;
    IntRegIndex op1;
    uint64_t imm;

    SveBinImmUnpredDestrOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), imm(_imm)
    {}
    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveBinImmIdxUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1;
    uint64_t imm;

    SveBinImmIdxUnpredOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveUnarySca2VecUnpredOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1;
    bool simdFp;

    SveUnarySca2VecUnpredOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            bool _simdFp) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), simdFp(_simdFp)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveDotProdIdxOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;
    uint64_t imm;
    uint8_t esize;

  public:
    SveDotProdIdxOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            IntRegIndex _op2, uint64_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveDotProdOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;
    uint8_t esize;

  public:
    SveDotProdOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            IntRegIndex _op2) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveComplexOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2, gp;
    uint8_t rot;

  public:
    SveComplexOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            IntRegIndex _op2, IntRegIndex _gp, uint8_t _rot) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), gp(_gp), rot(_rot)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};

class SveComplexIdxOp : public ArmStaticInst {
  protected:
    IntRegIndex dest, op1, op2;
    uint8_t rot, imm;

  public:
    SveComplexIdxOp(const char* mnem, ExtMachInst _machInst,
            OpClass __opClass, IntRegIndex _dest, IntRegIndex _op1,
            IntRegIndex _op2, uint8_t _rot, uint8_t _imm) :
        ArmStaticInst(mnem, _machInst, __opClass),
        dest(_dest), op1(_op1), op2(_op2), rot(_rot), imm(_imm)
    {}

    std::string generateDisassembly(Addr pc, const SymbolTable *symtab) const;
};


std::string sveDisasmPredCountImm(uint8_t imm);

unsigned int sveDecodePredCount(uint8_t imm, unsigned int num_elems);

uint64_t sveExpandFpImmAddSub(uint8_t imm, uint8_t size);

uint64_t sveExpandFpImmMaxMin(uint8_t imm, uint8_t size);

uint64_t sveExpandFpImmMul(uint8_t imm, uint8_t size);

}  // namespace ArmISA

#endif  // __ARCH_ARM_INSTS_SVE_HH__