#define _32BIT_EXTENSION(FI, TI, FROM, TO, REGTYPE, INSTR, TYPEINSTR, SHRINSTR, LSV, RSV) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(IL_AS##TYPEINSTR##_i32 newline; \
(SHRINSTR##_i32 newline; \
(SHL_i32 newline; \
(IL_ASINT_##FROM REGTYPE:$src), newline; \
(LOADCONST_i32 LSV)), newline; \
(LOADCONST_i32 RSV)))>; newline; newline;

#define _32BIT_EXTENSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, TYPEINSTR, SHRINSTR, LSV, RSV, VTYPE, ASVTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(IL_AS##TYPEINSTR##_##VTYPE##i32 newline; \
(SHRINSTR##_##VTYPE##i32 newline; \
(SHLVEC_##VTYPE##i32 newline; \
(IL_AS##ASVTYPE##INT_##FROM REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 LSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 RSV))))>; newline; newline;

#define _64BIT_ZEXTENSION(FI, TI, FROM, TO, REGTYPE, INSTR, TYPEINSTR, SHRINSTR, LSV, RSV, MASK) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(LCREATE newline; \
(SHRINSTR##_i32 newline; \
(SHL_i32 newline; \
(IL_ASINT_##FROM REGTYPE:$src), newline; \
(LOADCONST_i32 LSV)), newline; \
(LOADCONST_i32 RSV)), newline; \
(LOADCONST_i32 0))>; newline; newline;

#define _64BIT_ZEXTENSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, TYPEINSTR, SHRINSTR, LSV, RSV, MASK, VTYPE, ASVTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(LCREATE_##VTYPE##i64 newline; \
(SHRINSTR##_##VTYPE##i32 newline; \
(SHLVEC_##VTYPE##i32 newline; \
(IL_AS##ASVTYPE##INT_##FROM REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 LSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 RSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 0)))>; newline; newline;

#define _64BIT_SEXTENSION(FI, TI, FROM, TO, REGTYPE, INSTR, TYPEINSTR, SHRINSTR, LSV, RSV, MASK) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(LCREATE newline; \
(SHRINSTR##_i32 newline; \
(SHL_i32 newline; \
(IL_ASINT_##FROM REGTYPE:$src), newline; \
(LOADCONST_i32 LSV)), newline; \
(LOADCONST_i32 RSV)), newline; \
(SHRINSTR##_i32 newline; \
(SHL_i32 newline;  \
(IL_ASINT_##FROM REGTYPE:$src), newline; \
(LOADCONST_i32 LSV)), newline; \
(LOADCONST_i32 31)))>; newline; newline;

#define _64BIT_SEXTENSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, TYPEINSTR, SHRINSTR, LSV, RSV, MASK, VTYPE, ASVTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(LCREATE_##VTYPE##i64 newline; \
(SHRINSTR##_##VTYPE##i32 newline; \
(SHLVEC_##VTYPE##i32 newline; \
(IL_AS##ASVTYPE##INT_##FROM REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 LSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 RSV))), newline; \
(SHRINSTR##_##VTYPE##i32 newline; \
(SHLVEC_##VTYPE##i32 newline;  \
(IL_AS##ASVTYPE##INT_##FROM REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 LSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 31))))>; newline; newline;

#define _32BIT_F2I_CONVERSION(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, SHRINSTR, LSV, RSV, MASK) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline;  \
(TO  newline; \
(FPINSTR newline; \
(SHRINSTR##_i32 newline; \
(SHL_i32 newline; \
(IL_ASINT_##FROM REGTYPE:$src), newline; \
(LOADCONST_i32 LSV)), newline; \
(LOADCONST_i32 RSV))))>; newline; newline; 

#define _32BIT_F2I_CONVERSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, SHRINSTR, LSV, RSV, MASK, VTYPE, ASVTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline;  \
(TO  newline; \
(FPINSTR newline; \
(SHRINSTR##_##VTYPE##i32 newline; \
(SHLVEC_##VTYPE##i32 newline; \
(IL_AS##ASVTYPE##INT_##FROM REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 LSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 RSV)))))>; newline; newline; 

#define _32BIT_I2F_CONVERSION(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, MASK, TYPEINSTR) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(TO newline; \
(IL_AS##TYPEINSTR##_i32 newline; \
(BINARY_AND_i32 newline; \
(FPINSTR REGTYPE:$src), newline; \
(LOADCONST_i32 MASK))))>; newline; newline; 

#define _32BIT_I2F_CONVERSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, MASK, TYPEINSTR, VTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(TO newline; \
(IL_AS##TYPEINSTR##_##VTYPE##i32 newline; \
(BINARY_AND_##VTYPE##i32 newline; \
(FPINSTR REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 MASK)))))>; newline; newline; 

#define _32BIT_D2I_CONVERSION(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, SHRINSTR, LSV, RSV, MASK) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline;  \
(TO  (FTOD newline; \
(FPINSTR newline; \
(SHRINSTR##_i32 newline; \
(SHL_i32 newline; \
(IL_ASINT_##FROM REGTYPE:$src), newline; \
(LOADCONST_i32 LSV)), newline; \
(LOADCONST_i32 RSV)))))>; newline; newline; 

#define _32BIT_D2I_CONVERSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, SHRINSTR, LSV, RSV, MASK, VTYPE, ASVTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline;  \
(TO  (FTOD_##VTYPE##f64 newline; \
(FPINSTR newline; \
(SHRINSTR##_##VTYPE##i32 newline; \
(SHLVEC_##VTYPE##i32 newline; \
(IL_AS##ASVTYPE##INT_##FROM REGTYPE:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 LSV))), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 RSV))))))>; newline; newline; 

#define _32BIT_I2D_CONVERSION(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, MASK, TYPEINSTR) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(TO newline; \
(IL_AS##TYPEINSTR##_i32 newline; \
(BINARY_AND_i32 newline; \
(FPINSTR (DTOF REGTYPE:$src)), newline; \
(LOADCONST_i32 MASK))))>; newline; newline; 

#define _32BIT_I2D_CONVERSION_VEC(FI, TI, FROM, TO, REGTYPE, INSTR, FPINSTR, MASK, TYPEINSTR, VTYPE) \
def FI##to##TI##_##TO : Pat<(TO (INSTR REGTYPE:$src)), newline; \
(TO newline; \
(IL_AS##TYPEINSTR##_##VTYPE##i32 newline; \
(BINARY_AND_##VTYPE##i32 newline; \
(FPINSTR (DTOF_##VTYPE##f32 REGTYPE:$src)), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 MASK)))))>; newline; newline; 

#define _32BIT_TRUNCATE(FI, TI, FROM, TO, REGTYPE, ASTYPE, MASK, BITSHIFT) \
def FI##to##TI##_##TO : Pat<(TO (trunc REGTYPE:$src)), newline; \
(IL_AS##ASTYPE##_i32 newline; \
(IL_ASINT_##FROM newline; \
(BINARY_AND_##FROM REGTYPE:$src, newline; \
(LOADCONST_##FROM MASK))) newline;\
)>; newline; newline;

#define _32BIT_TRUNCATE_VEC(FI, TI, FROM, TO, REGTYPE, ASTYPE, MASK, VTYPE, SCALARFROM, BITSHIFT, ASVTYPE) \
def FI##to##TI##_##TO : Pat<(TO (trunc REGTYPE:$src)), newline; \
(IL_AS##ASTYPE##_##VTYPE##i32 newline; \
(IL_AS##ASVTYPE##INT_##FROM newline; \
(BINARY_AND_##FROM REGTYPE:$src, newline; \
(VCREATE_##VTYPE##SCALARFROM (LOADCONST_##SCALARFROM MASK)))) newline; \
)>; newline; newline;

#define _64BIT_TRUNCATE(TI, TO, ASTYPE, MASK, BITSHIFT) \
def lto##TI##_##TO : Pat<(TO (trunc GPRI64:$src)), newline; \
(IL_AS##ASTYPE##_i32 newline; \
(BINARY_AND_i32 newline; \
(LLO GPRI64:$src), newline; \
(LOADCONST_i32 MASK)) newline; \
)>; newline; newline;

#define _64BIT_TRUNCATE_VEC(TI, TO, ASTYPE, MASK, VTYPE, ASVTYPE, BITSHIFT) \
def lto##TI##_##TO : Pat<(TO (trunc GPR##ASVTYPE##I64:$src)), newline; \
(IL_AS##ASTYPE##_##VTYPE##i32 newline; \
(BINARY_AND_##VTYPE##i32 newline; \
(LLO_##VTYPE##i64 GPR##ASVTYPE##I64:$src), newline; \
(VCREATE_##VTYPE##i32 (LOADCONST_i32 MASK))) newline; \
)>; newline; newline;


#define GENERATE_32BIT_CONVERT(FI, TI, FROM, TO, FREGTYPE, ASTYPE, LSV, RSV) \
_32BIT_EXTENSION(a##FI, TI, FROM, TO, FREGTYPE, anyext, ASTYPE, USHR, LSV, RSV) \
_32BIT_EXTENSION(u##FI, TI, FROM, TO, FREGTYPE,   zext, ASTYPE, USHR, LSV, RSV) \
_32BIT_EXTENSION(s##FI, TI, FROM, TO, FREGTYPE,   sext, ASTYPE,  SHR, LSV, RSV) \

#define GENERATE_64BIT_CONVERT(FI, TI, FROM, TO, FREGTYPE, ASTYPE, LSV, RSV, MASK) \
_64BIT_ZEXTENSION(a##FI, TI, FROM, TO, FREGTYPE, anyext, ASTYPE, USHR, LSV, RSV, MASK) \
_64BIT_ZEXTENSION(u##FI, TI, FROM, TO, FREGTYPE,   zext, ASTYPE, USHR, LSV, RSV, MASK) \
_64BIT_SEXTENSION(s##FI, TI, FROM, TO, FREGTYPE,   sext, ASTYPE,  SHR, LSV, RSV, MASK) \

#define GENERATE_32BIT_FP_CONVERSION(FI, FROM, IREGTYPE, ASTYPE, LSV, RSV, MASK) \
_32BIT_F2I_CONVERSION(s##FI, f, FROM, f32, IREGTYPE, sint_to_fp, ITOF,  SHR, LSV, RSV, MASK) \
_32BIT_F2I_CONVERSION(u##FI, f, FROM, f32, IREGTYPE, uint_to_fp, UTOF, USHR, LSV, RSV, MASK) \
_32BIT_I2F_CONVERSION(f, s##FI, f32, FROM,   GPRF32, fp_to_sint, FTOI, MASK, ASTYPE) \
_32BIT_I2F_CONVERSION(f, u##FI, f32, FROM,   GPRF32, fp_to_uint, FTOU, MASK, ASTYPE) \
_32BIT_D2I_CONVERSION(s##FI, d, FROM, f64, IREGTYPE, sint_to_fp, ITOF,  SHR, LSV, RSV, MASK) \
_32BIT_D2I_CONVERSION(u##FI, d, FROM, f64, IREGTYPE, uint_to_fp, UTOF, USHR, LSV, RSV, MASK) \
_32BIT_I2D_CONVERSION(d, s##FI, f64, FROM,   GPRF64, fp_to_sint, FTOI, MASK, ASTYPE) \
_32BIT_I2D_CONVERSION(d, u##FI, f64, FROM,   GPRF64, fp_to_uint, FTOU, MASK, ASTYPE)

// Generate the conversion rountines
GENERATE_32BIT_CONVERT(c, s,  i8,  i16,  GPRI8, SHORT, 24, 24)
GENERATE_32BIT_CONVERT(c, i,  i8,  i32,  GPRI8,   INT, 24, 24)
GENERATE_64BIT_CONVERT(c, l,  i8,  i64,  GPRI8,  LONG, 24, 24, 0x000000FF)
GENERATE_32BIT_CONVERT(s, i, i16,  i32, GPRI16,   INT, 16, 16)
GENERATE_64BIT_CONVERT(s, l, i16,  i64, GPRI16,  LONG, 16, 16, 0x0000FFFF)
GENERATE_64BIT_CONVERT(i, l, i32,  i64, GPRI32,  LONG,  0,  0, 0xFFFFFFFF)

GENERATE_32BIT_FP_CONVERSION(c,  i8,  GPRI8, CHAR, 24, 24, 0x000000FF)
GENERATE_32BIT_FP_CONVERSION(s, i16, GPRI16, SHORT, 16, 16, 0x0000FFFF)


// Truncation Routines
_32BIT_TRUNCATE(s, c, i16,  i8, GPRI16,  CHAR, 0x000000FF, 24)
_32BIT_TRUNCATE(i, c, i32,  i8, GPRI32,  CHAR, 0x000000FF, 24)
_32BIT_TRUNCATE(i, s, i32, i16, GPRI32, SHORT, 0x0000FFFF, 16)
_64BIT_TRUNCATE(c,  i8,  CHAR, 0x000000FF, 24)
_64BIT_TRUNCATE(s, i16, SHORT, 0x0000FFFF, 16)
_64BIT_TRUNCATE(i, i32,   INT, 0xFFFFFFFF, 0)

// Vector Rountines
#define GENERATE_32BIT_CONVERT_VEC(FI, TI, FROM, TO, FREGTYPE, ASTYPE, LSV, RSV, VTYPE, ASVTYPE) \
_32BIT_EXTENSION_VEC(a##FI, TI, VTYPE##FROM, VTYPE##TO, FREGTYPE, anyext, ASTYPE, USHRVEC, LSV, RSV, VTYPE, ASVTYPE) \
_32BIT_EXTENSION_VEC(u##FI, TI, VTYPE##FROM, VTYPE##TO, FREGTYPE,   zext, ASTYPE, USHRVEC, LSV, RSV, VTYPE, ASVTYPE) \
_32BIT_EXTENSION_VEC(s##FI, TI, VTYPE##FROM, VTYPE##TO, FREGTYPE,   sext, ASTYPE,  SHRVEC, LSV, RSV, VTYPE, ASVTYPE) \

#define GENERATE_64BIT_CONVERT_VEC(FI, TI, FROM, TO, FREGTYPE, ASTYPE, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_64BIT_ZEXTENSION_VEC(a##FI, TI, VTYPE##FROM, VTYPE##TO, FREGTYPE, anyext, ASTYPE, USHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_64BIT_ZEXTENSION_VEC(u##FI, TI, VTYPE##FROM, VTYPE##TO, FREGTYPE,   zext, ASTYPE, USHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_64BIT_SEXTENSION_VEC(s##FI, TI, VTYPE##FROM, VTYPE##TO, FREGTYPE,   sext, ASTYPE,  SHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \

#define GENERATE_32BIT_FP_CONVERSION_VEC2(FI, FROM, IREGTYPE, ASTYPE, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_F2I_CONVERSION_VEC(s##FI, f, VTYPE##FROM, VTYPE##f32, IREGTYPE, sint_to_fp, ITOF_##VTYPE##f32,  SHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_F2I_CONVERSION_VEC(u##FI, f, VTYPE##FROM, VTYPE##f32, IREGTYPE, uint_to_fp, UTOF_##VTYPE##f32, USHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_I2F_CONVERSION_VEC(f, s##FI, VTYPE##f32, VTYPE##FROM,   GPRV2F32, fp_to_sint, FTOI_##VTYPE##i32, MASK, ASTYPE, VTYPE) \
_32BIT_I2F_CONVERSION_VEC(f, u##FI, VTYPE##f32, VTYPE##FROM,   GPRV2F32, fp_to_uint, FTOU_##VTYPE##i32, MASK, ASTYPE, VTYPE) \
_32BIT_D2I_CONVERSION_VEC(s##FI, d, VTYPE##FROM, VTYPE##f64, IREGTYPE, sint_to_fp, ITOF_##VTYPE##f32,  SHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_D2I_CONVERSION_VEC(u##FI, d, VTYPE##FROM, VTYPE##f64, IREGTYPE, uint_to_fp, UTOF_##VTYPE##f32, USHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_I2D_CONVERSION_VEC(d, s##FI, VTYPE##f64, VTYPE##FROM,   GPRV2F64, fp_to_sint, FTOI_##VTYPE##i32, MASK, ASTYPE, VTYPE) \
_32BIT_I2D_CONVERSION_VEC(d, u##FI, VTYPE##f64, VTYPE##FROM,   GPRV2F64, fp_to_uint, FTOU_##VTYPE##i32, MASK, ASTYPE, VTYPE)

#define GENERATE_32BIT_FP_CONVERSION_VEC4(FI, FROM, IREGTYPE, ASTYPE, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_F2I_CONVERSION_VEC(s##FI, f, VTYPE##FROM, VTYPE##f32, IREGTYPE, sint_to_fp, ITOF_##VTYPE##f32,  SHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_F2I_CONVERSION_VEC(u##FI, f, VTYPE##FROM, VTYPE##f32, IREGTYPE, uint_to_fp, UTOF_##VTYPE##f32, USHRVEC, LSV, RSV, MASK, VTYPE, ASVTYPE) \
_32BIT_I2F_CONVERSION_VEC(f, s##FI, VTYPE##f32, VTYPE##FROM,   GPRV4F32, fp_to_sint, FTOI_##VTYPE##i32, MASK, ASTYPE, VTYPE) \
_32BIT_I2F_CONVERSION_VEC(f, u##FI, VTYPE##f32, VTYPE##FROM,   GPRV4F32, fp_to_uint, FTOU_##VTYPE##i32, MASK, ASTYPE, VTYPE) 

// Generate the conversion rountines for 2 component vectors
GENERATE_32BIT_CONVERT_VEC(c, s,  i8,  i16,  GPRV2I8, V2SHORT, 24, 24, v2, V2)
GENERATE_32BIT_CONVERT_VEC(c, i,  i8,  i32,  GPRV2I8,   V2INT, 24, 24, v2, V2)
GENERATE_64BIT_CONVERT_VEC(c, l,  i8,  i64,  GPRV2I8,  V2LONG, 24, 24, 0x000000FF, v2, V2)
GENERATE_32BIT_CONVERT_VEC(s, i, i16,  i32, GPRV2I16,   V2INT, 16, 16, v2, V2)
GENERATE_64BIT_CONVERT_VEC(s, l, i16,  i64, GPRV2I16,  V2LONG, 16, 16, 0x0000FFFF, v2, V2)
GENERATE_64BIT_CONVERT_VEC(i, l, i32,  i64, GPRV2I32,  V2LONG,  0,  0, 0xFFFFFFFF, v2, V2)

GENERATE_32BIT_FP_CONVERSION_VEC2(c,  i8,  GPRV2I8,  V2CHAR, 24, 24, 0x000000FF, v2, V2)
GENERATE_32BIT_FP_CONVERSION_VEC2(s, i16, GPRV2I16, V2SHORT, 16, 16, 0x0000FFFF, v2, V2)


// Truncation Routines
_32BIT_TRUNCATE_VEC(s, c, v2i16,  v2i8, GPRV2I16,  V2CHAR, 0x000000FF, v2, i16, 24, V2)
_32BIT_TRUNCATE_VEC(i, c, v2i32,  v2i8, GPRV2I32,  V2CHAR, 0x000000FF, v2, i32, 24, V2)
_32BIT_TRUNCATE_VEC(i, s, v2i32, v2i16, GPRV2I32, V2SHORT, 0x0000FFFF, v2, i32, 16, V2)
_64BIT_TRUNCATE_VEC(c,  v2i8,  V2CHAR, 0x000000FF, v2, V2, 24)
_64BIT_TRUNCATE_VEC(s, v2i16, V2SHORT, 0x0000FFFF, v2, V2, 16)
_64BIT_TRUNCATE_VEC(i, v2i32,   V2INT, 0xFFFFFFFF, v2, V2, 0)

// Generate the conversion rountines for 4 component vectors
GENERATE_32BIT_CONVERT_VEC(c, s,  i8,  i16,  GPRV4I8, V4SHORT, 24, 24, v4, V4)
GENERATE_32BIT_CONVERT_VEC(c, i,  i8,  i32,  GPRV4I8,   V4INT, 24, 24, v4, V4)
GENERATE_32BIT_CONVERT_VEC(s, i, i16,  i32, GPRV4I16,   V4INT, 16, 16, v4, V4)

GENERATE_32BIT_FP_CONVERSION_VEC4(c,  i8,  GPRV4I8,  V4CHAR, 24, 24, 0x000000FF, v4, V4)
GENERATE_32BIT_FP_CONVERSION_VEC4(s, i16, GPRV4I16, V4SHORT, 16, 16, 0x0000FFFF, v4, V4)


// Truncation Routines
_32BIT_TRUNCATE_VEC(s, c, v4i16,  v4i8, GPRV4I16,  V4CHAR, 0x000000FF, v4, i16, 24, V4)
_32BIT_TRUNCATE_VEC(i, c, v4i32,  v4i8, GPRV4I32,  V4CHAR, 0x000000FF, v4, i32, 24, V4)
_32BIT_TRUNCATE_VEC(i, s, v4i32, v4i16, GPRV4I32, V4SHORT, 0x0000FFFF, v4, i32, 16, V4)