PTXOperand.h

Go to the documentation of this file.

#ifndef IR_PTXOPERAND_H_INCLUDED
#define IR_PTXOPERAND_H_INCLUDED

#include <string>
#include <vector>
#include <functional>
#include <ocelot/ir/interface/Instruction.h>

namespace ir {

  typedef unsigned char PTXU8;
  typedef unsigned short PTXU16;
  typedef unsigned int PTXU32;
  typedef unsigned long long PTXU64;
  
  typedef char PTXS8;
  typedef short PTXS16;
  typedef int PTXS32;
  typedef long long PTXS64;
  
  typedef float PTXF32;
  typedef double PTXF64;
  
  typedef PTXU8 PTXB8;
  typedef PTXU16 PTXB16;
  typedef PTXU32 PTXB32;
  typedef PTXU64 PTXB64;

  class PTXOperand {
  public:
    enum AddressMode {
      Register,     
      Indirect,     
      Immediate,      
      Address,      
      Label,        
      Special,      
      ArgumentList,       
      FunctionName,       
      BitBucket,      
      Invalid
    };

    enum DataType {
      s8 = 0,
      s16,
      s32,
      s64,
      u8 = 4,
      u16,
      u32,
      u64,
      f16 = 8,
      f32,
      f64,
      b8,
      b16,
      b32,
      b64,
      pred,
      TypeSpecifier_invalid
    };

    enum SpecialRegister {
      tid,
      ntid,
      laneId,
      warpId,
      nwarpId,
      warpSize,
      ctaId,
      nctaId,
      smId,
      nsmId,
      gridId,
      clock,
      clock64,
      lanemask_eq,
      lanemask_le,
      lanemask_lt,
      lanemask_ge,
      lanemask_gt,
      pm0,
      pm1,
      pm2,
      pm3,
      envreg0,
      envreg1,
      envreg2,
      envreg3,
      envreg4,
      envreg5,
      envreg6,
      envreg7,
      envreg8,
      envreg9,
      envreg10,
      envreg11,
      envreg12,
      envreg13,
      envreg14,
      envreg15,
      envreg16,
      envreg17,
      envreg18,
      envreg19,
      envreg20,
      envreg21,
      envreg22,
      envreg23,
      envreg24,
      envreg25,
      envreg26,
      envreg27,
      envreg28,
      envreg29,
      envreg30,
      envreg31,
      SpecialRegister_invalid
    };
    
    enum PredicateCondition {
      Pred,   //< instruction executes if predicate is true
      InvPred,  //< instruction executes if predicate is false
      PT,     //< predicate is always true
      nPT     //< predicate is always false
    };
  
    enum Vec {
      v1 = 1,       //< scalar
      v2 = 2,       //< vector2
      v4 = 4        //< vector4
    };
    
    enum VectorIndex {
      iAll = 0, 
      ix = 1, 
      iy = 2, 
      iz = 3, 
      iw = 4 
    };

    typedef std::vector<PTXOperand> Array;

    typedef Instruction::RegisterType RegisterType;

  public:
    static std::string toString(VectorIndex);
    static std::string toString(DataType);
    static std::string toString(SpecialRegister);
    static std::string toString(AddressMode);
    static std::string toString(DataType, RegisterType);
    static bool isFloat(DataType);
    static bool isInt(DataType);
    static bool isSigned(DataType);
    static unsigned int bytes(DataType);
    static bool valid(DataType, DataType);
    static bool relaxedValid(DataType instructionType, DataType);
    static long long unsigned int maxInt(DataType type);
    static long long unsigned int minInt(DataType type);
    
  public:
    PTXOperand();
    PTXOperand(SpecialRegister r, VectorIndex i = iAll, DataType t = u32);
    PTXOperand(const std::string& label);
    PTXOperand(AddressMode m, DataType t, RegisterType r = 0, 
      int o = 0, Vec v = v1);
    PTXOperand(AddressMode m, DataType t, const std::string& identifier, 
      int o = 0, Vec v = v1);
    PTXOperand(AddressMode m, const std::string& identifier);
    PTXOperand(long long unsigned int v, DataType t = u64);
    ~PTXOperand();

    std::string toString() const;
    std::string registerName() const;
    unsigned int bytes() const;
    bool isRegister() const;

    std::string identifier;
    
    AddressMode addressMode;

    DataType type;

    union {
      int offset;
      VectorIndex vIndex;
      unsigned int registerCount;
    };
    
    union {
      long long unsigned int imm_uint;
      long long int imm_int;
      double imm_float;
      PredicateCondition condition;
      SpecialRegister special;
      unsigned int localMemorySize;
    };

    union {
      RegisterType reg;
      bool isArgument;
      bool isGlobalLocal;
      unsigned int sharedMemorySize;
    };
    
    union {
      Vec vec;
      unsigned int stackMemorySize;
    };
    
    Array array;
    
  };

}

namespace std 
{
  template<> 
  struct hash<ir::PTXOperand::DataType>
  {
  public:
    size_t operator()(const ir::PTXOperand::DataType& t) const
    {
      return (size_t)t;
    }
  };
}

#endif