globals.H

Go to the documentation of this file.

#ifndef LEGOGLOBALS_H
#define LEGOGLOBALS_H

/*
 *  9/04/97 WAH: Fixed typo in statystypes; added more UNDEFs.
 *  9/23/97 WAH: Added addrStyles enum; expanded oprdTypes, dataTypes;
 *               changed OT_BOOLEAN to OT_LITERAL_P.
 * 11/12/01 MCT: Added IA-64 opcode info: class, bases, qualifiers.
 */

#define LARGE_INTVAL 32767
#define MAX_INT 32767

enum oprdTypes {
   OT_VACANT=0,
   OT_LITERAL_VO,                 // void
   OT_LITERAL_BO,                 // boolean (not guard)
   OT_LITERAL_CH,                 // char
   OT_LITERAL_UCH,                // unsigned char
   OT_LITERAL_SH,                 // short
   OT_LITERAL_USH,                // unsigned short
   OT_LITERAL_I,                  // integer (original)
   OT_LITERAL_UI,                 // unsigned integer
   OT_LITERAL_LNG,                // long
   OT_LITERAL_ULNG,               // unsigned long
   OT_LITERAL_LLNG,               // long long
   OT_LITERAL_ULLNG,              // unsigned long long
   OT_LITERAL_LLLNG,              // long long long
   OT_LITERAL_ULLLNG,             // unsigned long long long
   OT_LITERAL_PTR,                // pointer
   OT_LITERAL_F,                  // float (original)
   OT_LITERAL_D,                  // double (original)
   OT_LITERAL_C,                  // character (deprecated?)
   OT_LITERAL_L,                  // label (original)
   OT_LITERAL_S,                  // string (original)
   OT_LITERAL_CB,                 // branch target/control block (original)
   OT_LITERAL_P,                  // used for predicate (original)
   OT_REG,                        // register
   OT_MACRO,                      // macro
   OT_UNDEFINED                   // u<>, also initialization type
};

enum regTypes {
   RT_R = 0,
   RT_VR,                         // unbounded virt reg
   RT_MVR,                        // memory virt reg
   RT_FR,                         // floating-point reg
   RT_BR                          // branch reg (?)
};

enum dataTypes {
   DT_VO=0,                       // Void
   DT_BO,                         // Boolean (not guard)
   DT_CH,                         // Char
   DT_UCH,                        // Unsigned char
   DT_SH,                         // Short
   DT_USH,                        // Unsigned short
   DT_I,                          // Integer (original)
   DT_UI,                         // Unsigned integer
   DT_LNG,                        // Long
   DT_ULNG,                       // Unsigned long
   DT_LLNG,                       // Long long
   DT_ULLNG,                      // Unsigned long long
   DT_LLLNG,                      // Long long long
   DT_ULLLNG,                     // Unsigned long long long
   DT_PTR,                        // Pointer
   DT_F,                          // Floating-point (original)
   DT_D,                          // Double (original)
   DT_P,                          // Predicate (original)
   DT_B                           // Branch target (original)
};

enum fileTypes {
   FT_GPR=0,                      // general purpose register
   FT_FPR,                        // floating-point register
   FT_PR,                         // predicate register
   FT_BTR,                        // branch target register
   FT_CR                          // control register ???
};

enum regStyles {
  RS_STATIC='s',                  // static registers
  RS_ROTATING='r'                 // rotating registers
};

enum addrStyles {
  AS_UNDEF=0,                     // undefined
  AS_G_ABS,                       // visible globally, absolute addressing
  AS_G_GP,                        //    "       "    , GP-relative addressing
  AS_L_ABS,                       // visible locally,  absolute addressing
  AS_L_GP                         //    "       "   ,  GP-relative addressing
};

enum attrTypes {
   ATTR_UNDEF,                    // undefined
   ATTR_LC=1,                     // lcode
   ATTR_MS,                       // unimplemented
   ATTR_BBID,                     // basic block id
   ATTR_FREQ,                     // frequency
   ATTR_LIVE,                     // live registers
   //   ATTR_PROF,                     // profile attribute
   ATTR_TBLNAME                   // jump table name
};

enum edgeTypes {
   ET_UNDEF = 0,
   ET_CNTL = 1,                   // control flow
   ET_REGFLOW,                    // flow-dependence
   ET_REGANTI,                    // anti-dependence
   ET_REGOUT,                     // output-dependence
   ET_MEM,                        // memory
   ET_LINKDEST,                   // link for dag construction
   ET_LINKSRC,                    // link for dag construction
};

enum portTypes {
   PT_UNDEF = 0,
   PT_FIRST = 1,
   PT_CTL,
   PT_MEM,
   PT_SRC,
   PT_DEST
};

enum usageTypes {
   USAGE_UNDEF = 0,
   USAGE_SEM = 1,
   USAGE_ANN
};

enum statusTypes {
   STATUS_UNDEF = -1,
   STATUS_CERTAIN = 0,
   STATUS_MAYBE
};


enum opCodeClass {
   OC_UNDEF = 0,
   OC_INT,              // integer alu opcodes
   OC_PINT,             // integer SIMD alu opcodes
   OC_FP,               // floating-point alu opcodes
   OC_PFP,              // floating-point SIMD alu opcodes
   OC_CMP,              // integer compare opcodes
   OC_FCMP,             // floating-point compare opcodes
   OC_BR,               // branch opcodes
   OC_LDST,             // integer memory/load-store opcodes
   OC_FPLDST,           // floating-point memory/load-store opcodes
   OC_MISC,             // miscellaneous opcodes
   OC_VSS,              // TINKER value speculation scheduling opcodes
   OC_DIR               // IA-64 assembly directives
};

 

enum oprdSizeQual {
   OS_NA = -1,
   OS_B = 0,    // 1 byte
   OS_H,        // 2 byte
   OS_W,        // 4 byte
   OS_X,        // 8 byte
};

enum cmpTypeQual {
   CT_NA = -1,
   CT_NONE = 0,
   CT_UNC,
   CT_OR,
   CT_AND,
   CT_ORANDCM,
   CT_ORCM,
   CT_ANDCM,
   CT_ANDORCM
};

enum cmpRelationQual {
   CR_NA = -1,
   CR_EQ = 0,
   CR_NE,
   CR_LT,
   CR_LE,
   CR_GT,
   CR_GE,
   CR_LTU,
   CR_LEU,
   CR_GTU,
   CR_GEU
};

enum pcmpRelationQual {
   PCR_NA = -1,
   PCR_EQ = 0,
   PCR_GT
};

enum testBitRelationQual {
   TBR_NA = -1,
   TBR_NZ = 0,
   TBR_Z
};

enum fpPrecCtrlQual {
   FPP_NA = -1,
   FPP_NONE = 0,
   FPP_S,               // 4 bytes - single precision
   FPP_D                // 8 bytes - double precision
};

enum fpStatusFieldQual {
   FPSF_NA = -1,
   FPSF_NONE = 0,
   FPSF_F0,
   FPSF_F1,
   FPSF_F2,
   FPSF_F3
};

enum fpClassRelationQual {
   FPCR_NA = -1,
   FPCR_M = 0,
   FPCR_NM
};

enum fpCmpTypeQual {
   FCT_NA = -1,
   FCT_NONE = 0,
   FCT_UNC
};

enum fpCmpRelationQual {
   FCR_NA = -1,
   FCR_EQ = 0,
   FCR_LT,
   FCR_LE,
   FCR_GT,
   FCR_GE,
   FCR_UNORD,
   FCR_NEQ,
   FCR_NLT,
   FCR_NLE,
   FCR_NGT,
   FCR_NGE,
   FCR_ORD
};

enum semaphoreTypeQual {
   FAS_NA = -1,
   FAS_ACQ = 0,
   FAS_REL
};

enum loadStoreTypeQual {
   LST_NA = -1,
   LST_NONE = 0,

   // load types
   LST_S,
   LST_A,
   LST_SA,
   LST_CNC,
   LST_CC,
   LST_CCACQ,
   LST_ACQ,
   LST_BIAS,
   LST_FILL,

   // line fetch types
   LST_NONEEXC,
   LST_FAULT,
   LST_FAULTEXC,

   // store types
   LST_REL,
   LST_SPILL
};

enum loadStoreHintQual {
   LSH_NA = -1,
   LSH_NONE = 0,
   LSH_NT1,
   LSH_NT2,
   LSH_NTA
};

enum fpLoadStoreSizeQual {
   FLSS_NA = -1,
   FLSS_NONE = 0,
   FLSS_S,              // 4 bytes
   FLSS_D,              // 8 bytes
   FLSS_E,              // 10 bytes
   FLSS_I               // int format
};

enum branchTypeQual {
   BT_NA = -1,
   BT_NONE = 0,
   BT_COND,
   BT_CALL,
   BT_RET,
   BT_IA32,
   BT_CLOOP,
   BT_CTOP,
   BT_CEXIT,
   BT_WTOP,
   BT_WEXIT
};

enum branchPredHintQual {
   BH_NA = -1,
   BH_NONE = 0,
   BH_SNT,
   BH_ST,
   BH_DNT,
   BH_DT
};

enum branchPrefetchHintQual {
   BPH = -1,
   BPH_NONE = 0,
   BPH_FEW,
   BPH_MANY
};

enum branchDeallocHintQual {
   BDH_NA = -1,
   BDH_NONE = 0,
   BDH_CLR
};

enum alatClearQual {
   AC_NA = -1,
   AC_CLR = 0,
   AC_NC
};

enum opFormLeftRightQual {
   OFLR_NA = -1,
   OFLR_NONE = 0,
   OFLR_L,
   OFLR_R,
   OFLR_LR
};

enum opFormMergeZeroQual {
   OFMZ_NA = -1,
   OFMZ_ZERO = 0,
   OFMZ_MERGE
};

enum opFormSignQual {
   OFS_NA = -1,
   OFS_SIGNED = 0,
   OFS_UNSIGNED
};

enum opFormUnitQual {
   OFMU_NA = -1,
   OFMU_NONE = 0,
   OFMU_I,
   OFMU_B,
   OFMU_M,
   OFMU_F,
   OFMU_X,
   OFMU_RET
};

enum opFormHighLowQual {
   OFHL_NA = -1,
   OFHL_LOW = 0,
   OFHL_HIGH
};

enum opFormFMergeQual {
   OFFM_NA = -1,
   OFFM_SIGN = 0,
   OFFM_NEGSIGN,
   OFFM_EXP,
};

enum opFormGetSetFormatQual {
   OFFC_NA = -1,
   OFFC_S = 0,
   OFFC_D,
   OFFC_EXP,
   OFFC_SIG
};

enum opFormTruncQual {
   OFT_NA = -1,
   OFT_NOTRUNC = 0,
   OFT_TRUNC
};

enum opFormCvtTypeQual {
   OFCV_NA = -1,
   OFCV_FX = 0,
   OFCV_FXU,
   OFCV_XF,
   OFCV_XUF
};

enum opFormFenceQual {
   OFMF_NA = -1,
   OFMF_ORD = 0,
   OFMF_ACC
};

enum opFormSaturationQual {
   OFSF_NA = -1,
   OFSF_MOD = 0,
   OFSF_SSS,
   OFSF_USS,
   OFSF_UUS,
   OFSF_UUU
};

enum opFormRoundQual {
   OFR_NA = -1,
   OFR_NORM = 0,
   OFR_RAZ   
};

enum opFormRegTypeQual {
   OFRT_NA = -1,
   OFRT_GR = 0,
   OFRT_FR
};

enum opFormSpecChkQual {
   OFSC_NA = -1,
   OFSC_CONTROL = 0,
   OFSC_DATA
};

enum opFormClearRRBQual {
   OFCR_NA = -1,
   OFCR_ALL = 0,
   OFCR_PRED
};

#endif /* LEGOGLOBALS_H */

---