[llvm-commits] CVS: llvm/include/llvm/CodeGen/SelectionDAGNodes.h ValueTypes.h
Chris Lattner
lattner at cs.uiuc.edu
Sat Mar 18 21:26:57 PST 2006
Changes in directory llvm/include/llvm/CodeGen:
SelectionDAGNodes.h updated: 1.114 -> 1.115
ValueTypes.h updated: 1.22 -> 1.23
---
Log message:
improve comments, add a new MVT::getVectorBaseType method.
---
Diffs of the changes: (+71 -40)
SelectionDAGNodes.h | 14 ++++---
ValueTypes.h | 97 +++++++++++++++++++++++++++++++++-------------------
2 files changed, 71 insertions(+), 40 deletions(-)
Index: llvm/include/llvm/CodeGen/SelectionDAGNodes.h
diff -u llvm/include/llvm/CodeGen/SelectionDAGNodes.h:1.114 llvm/include/llvm/CodeGen/SelectionDAGNodes.h:1.115
--- llvm/include/llvm/CodeGen/SelectionDAGNodes.h:1.114 Sat Mar 18 18:52:25 2006
+++ llvm/include/llvm/CodeGen/SelectionDAGNodes.h Sat Mar 18 23:26:45 2006
@@ -166,7 +166,12 @@
/// 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 @@
// 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
Index: llvm/include/llvm/CodeGen/ValueTypes.h
diff -u llvm/include/llvm/CodeGen/ValueTypes.h:1.22 llvm/include/llvm/CodeGen/ValueTypes.h:1.23
--- llvm/include/llvm/CodeGen/ValueTypes.h:1.22 Thu Mar 16 13:42:44 2006
+++ llvm/include/llvm/CodeGen/ValueTypes.h Sat Mar 18 23:26:45 2006
@@ -66,20 +66,55 @@
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 @@
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 @@
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);
More information about the llvm-commits
mailing list