From 210721aecc0916315f61660dc387a96b89ec423b Mon Sep 17 00:00:00 2001 From: Chris Lattner Date: Sun, 19 Mar 2006 05:26:45 +0000 Subject: [PATCH] improve comments, add a new MVT::getVectorBaseType method. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@26855 91177308-0d34-0410-b5e6-96231b3b80d8 --- include/llvm/CodeGen/SelectionDAGNodes.h | 14 ++-- include/llvm/CodeGen/ValueTypes.h | 97 +++++++++++++++--------- 2 files changed, 71 insertions(+), 40 deletions(-) diff --git a/include/llvm/CodeGen/SelectionDAGNodes.h b/include/llvm/CodeGen/SelectionDAGNodes.h index 648e9ddc452..e52ac2c8bd0 100644 --- a/include/llvm/CodeGen/SelectionDAGNodes.h +++ b/include/llvm/CodeGen/SelectionDAGNodes.h @@ -166,7 +166,12 @@ namespace ISD { /// their last two operands. VADD, VSUB, VMUL, VSDIV, VUDIV, VAND, VOR, VXOR, - + + /// SCALAR_TO_VECTOR(VAL) - This represents the operation of loading a + /// scalar value into the low element of the resultant vector type. The top + /// elements of the vector are undefined. + SCALAR_TO_VECTOR, + // MULHU/MULHS - Multiply high - Multiply two integers of type iN, producing // an unsigned/signed value of type i[2*n], then return the top part. MULHU, MULHS, @@ -281,10 +286,9 @@ namespace ISD { // integer result type. // ZEXTLOAD loads the integer operand and zero extends it to a larger // integer result type. - // EXTLOAD is used for two things: floating point extending loads, and - // integer extending loads where it doesn't matter what the high - // bits are set to. The code generator is allowed to codegen this - // into whichever operation is more efficient. + // EXTLOAD is used for three things: floating point extending loads, + // integer extending loads [the top bits are undefined], and vector + // extending loads [load into low elt]. EXTLOAD, SEXTLOAD, ZEXTLOAD, // TRUNCSTORE - This operators truncates (for integer) or rounds (for FP) a diff --git a/include/llvm/CodeGen/ValueTypes.h b/include/llvm/CodeGen/ValueTypes.h index 206b4938017..88eddd2c033 100644 --- a/include/llvm/CodeGen/ValueTypes.h +++ b/include/llvm/CodeGen/ValueTypes.h @@ -66,20 +66,55 @@ namespace MVT { // MVT = Machine Value Types LAST_VALUETYPE = 24 // This always remains at the end of the list. }; + /// MVT::isInteger - Return true if this is a simple integer, or a packed + /// vector integer type. static inline bool isInteger(ValueType VT) { return (VT >= i1 && VT <= i128) || (VT >= v8i8 && VT <= v2i64); } + + /// MVT::isFloatingPoint - Return true if this is a simple FP, or a packed + /// vector FP type. static inline bool isFloatingPoint(ValueType VT) { return (VT >= f32 && VT <= f128) || (VT >= v4f32 && VT <= v2f64); } + + /// MVT::isVector - Return true if this is a packed vector type (i.e. not + /// MVT::Vector). static inline bool isVector(ValueType VT) { - return (VT >= FIRST_VECTOR_VALUETYPE && - VT <= LAST_VECTOR_VALUETYPE); + return VT >= FIRST_VECTOR_VALUETYPE && VT <= LAST_VECTOR_VALUETYPE; } - /// getVectorType - Returns the ValueType that represents a vector NumElements - /// in length, where each element is of type VT. If there is no ValueType - /// that represents this vector, a ValueType of Other is returned. + /// MVT::getSizeInBits - Return the size of the specified value type in bits. + /// + static inline unsigned getSizeInBits(ValueType VT) { + switch (VT) { + default: assert(0 && "ValueType has no known size!"); + case MVT::i1 : return 1; + case MVT::i8 : return 8; + case MVT::i16 : return 16; + case MVT::f32 : + case MVT::i32 : return 32; + case MVT::f64 : + case MVT::i64 : + case MVT::v8i8: + case MVT::v4i16: + case MVT::v2i32: + case MVT::v2f32: return 64; + case MVT::f80 : return 80; + case MVT::f128: + case MVT::i128: + case MVT::v16i8: + case MVT::v8i16: + case MVT::v4i32: + case MVT::v2i64: + case MVT::v4f32: + case MVT::v2f64: return 128; + } + } + + /// MVT::getVectorType - Returns the ValueType that represents a vector + /// NumElements in length, where each element is of type VT. If there is no + /// ValueType that represents this vector, a ValueType of Other is returned. /// static inline ValueType getVectorType(ValueType VT, unsigned NumElements) { switch (VT) { @@ -88,19 +123,19 @@ namespace MVT { // MVT = Machine Value Types case MVT::i8: if (NumElements == 8) return MVT::v8i8; if (NumElements == 16) return MVT::v16i8; - break; + break; case MVT::i16: if (NumElements == 4) return MVT::v4i16; if (NumElements == 8) return MVT::v8i16; - break; + break; case MVT::i32: if (NumElements == 2) return MVT::v2i32; if (NumElements == 4) return MVT::v4i32; - break; + break; case MVT::f32: if (NumElements == 2) return MVT::v2f32; if (NumElements == 4) return MVT::v4f32; - break; + break; case MVT::f64: if (NumElements == 2) return MVT::v2f64; break; @@ -108,40 +143,32 @@ namespace MVT { // MVT = Machine Value Types return MVT::Other; } - static inline unsigned getSizeInBits(ValueType VT) { + /// MVT::getVectorBaseType - Given a packed vector type, return the type of + /// each element. + static inline ValueType getVectorBaseType(ValueType VT) { switch (VT) { - default: assert(0 && "ValueType has no known size!"); - case MVT::i1 : return 1; - case MVT::i8 : return 8; - case MVT::i16 : return 16; - case MVT::f32 : - case MVT::i32 : return 32; - case MVT::f64 : - case MVT::i64 : - case MVT::v8i8: - case MVT::v4i16: - case MVT::v2i32: - case MVT::v2f32: return 64; - case MVT::f80 : return 80; - case MVT::f128: - case MVT::i128: - case MVT::v16i8: - case MVT::v8i16: - case MVT::v4i32: - case MVT::v2i64: - case MVT::v4f32: - case MVT::v2f64: return 128; + default: assert(0 && "Invalid vector type!"); + case v8i8 : + case v16i8: return i8; + case v4i16: + case v8i16: return i16; + case v2i32: + case v4i32: return i32; + case v2i64: return i64; + case v2f32: + case v4f32: return f32; + case v2f64: return f64; } } - /// getIntVTBitMask - Return an integer with 1's every place there are bits - /// in the specified integer value type. + /// MVT::getIntVTBitMask - Return an integer with 1's every place there are + /// bits in the specified integer value type. static inline uint64_t getIntVTBitMask(ValueType VT) { assert(isInteger(VT) && !isVector(VT) && "Only applies to int scalars!"); return ~0ULL >> (64-getSizeInBits(VT)); } - /// getIntVTSignBit - Return an integer with a 1 in the position of the sign - /// bit for the specified integer value type. + /// MVT::getIntVTSignBit - Return an integer with a 1 in the position of the + /// sign bit for the specified integer value type. static inline uint64_t getIntVTSignBit(ValueType VT) { assert(isInteger(VT) && !isVector(VT) && "Only applies to int scalars!"); return 1ULL << (getSizeInBits(VT)-1); -- 2.34.1