class LLT {
public:
+ enum TypeKind : uint16_t {
+ Invalid,
+ Scalar,
+ Pointer,
+ Vector,
+ };
+
/// Get a low-level scalar or aggregate "bag of bits".
static LLT scalar(unsigned SizeInBits) {
assert(SizeInBits > 0 && "invalid scalar size");
- return LLT{/*isPointer=*/false, /*isVector=*/false, /*NumElements=*/0,
- SizeInBits, /*AddressSpace=*/0};
+ return LLT{Scalar, 1, SizeInBits};
}
/// Get a low-level pointer in the given address space (defaulting to 0).
static LLT pointer(uint16_t AddressSpace, unsigned SizeInBits) {
- assert(SizeInBits > 0 && "invalid pointer size");
- return LLT{/*isPointer=*/true, /*isVector=*/false, /*NumElements=*/0,
- SizeInBits, AddressSpace};
+ return LLT{Pointer, AddressSpace, SizeInBits};
}
/// Get a low-level vector of some number of elements and element width.
/// \p NumElements must be at least 2.
static LLT vector(uint16_t NumElements, unsigned ScalarSizeInBits) {
assert(NumElements > 1 && "invalid number of vector elements");
- assert(ScalarSizeInBits > 0 && "invalid vector element size");
- return LLT{/*isPointer=*/false, /*isVector=*/true, NumElements,
- ScalarSizeInBits, /*AddressSpace=*/0};
+ return LLT{Vector, NumElements, ScalarSizeInBits};
}
/// Get a low-level vector of some number of elements and element type.
static LLT vector(uint16_t NumElements, LLT ScalarTy) {
assert(NumElements > 1 && "invalid number of vector elements");
- assert(!ScalarTy.isVector() && "invalid vector element type");
- return LLT{ScalarTy.isPointer(), /*isVector=*/true, NumElements,
- ScalarTy.getSizeInBits(),
- ScalarTy.isPointer() ? ScalarTy.getAddressSpace() : 0};
+ assert(ScalarTy.isScalar() && "invalid vector element type");
+ return LLT{Vector, NumElements, ScalarTy.getSizeInBits()};
}
- explicit LLT(bool isPointer, bool isVector, uint16_t NumElements,
- unsigned SizeInBits, unsigned AddressSpace) {
- init(isPointer, isVector, NumElements, SizeInBits, AddressSpace);
+ explicit LLT(TypeKind Kind, uint16_t NumElements, unsigned SizeInBits)
+ : SizeInBits(SizeInBits), ElementsOrAddrSpace(NumElements), Kind(Kind) {
+ assert((Kind != Vector || ElementsOrAddrSpace > 1) &&
+ "invalid number of vector elements");
}
- explicit LLT() : IsPointer(false), IsVector(false), RawData(0) {}
+
+ explicit LLT() : SizeInBits(0), ElementsOrAddrSpace(0), Kind(Invalid) {}
explicit LLT(MVT VT);
- bool isValid() const { return RawData != 0; }
+ bool isValid() const { return Kind != Invalid; }
- bool isScalar() const { return isValid() && !IsPointer && !IsVector; }
+ bool isScalar() const { return Kind == Scalar; }
- bool isPointer() const { return isValid() && IsPointer && !IsVector; }
+ bool isPointer() const { return Kind == Pointer; }
- bool isVector() const { return isValid() && IsVector; }
+ bool isVector() const { return Kind == Vector; }
/// Returns the number of elements in a vector LLT. Must only be called on
/// vector types.
uint16_t getNumElements() const {
- assert(IsVector && "cannot get number of elements on scalar/aggregate");
- if (!IsPointer)
- return getFieldValue(VectorElementsFieldInfo);
- else
- return getFieldValue(PointerVectorElementsFieldInfo);
+ assert(isVector() && "cannot get number of elements on scalar/aggregate");
+ return ElementsOrAddrSpace;
}
/// Returns the total size of the type. Must only be called on sized types.
unsigned getSizeInBits() const {
if (isPointer() || isScalar())
- return getScalarSizeInBits();
- return getScalarSizeInBits() * getNumElements();
+ return SizeInBits;
+ return SizeInBits * ElementsOrAddrSpace;
}
unsigned getScalarSizeInBits() const {
- assert(RawData != 0 && "Invalid Type");
- if (!IsVector) {
- if (!IsPointer)
- return getFieldValue(ScalarSizeFieldInfo);
- else
- return getFieldValue(PointerSizeFieldInfo);
- } else {
- if (!IsPointer)
- return getFieldValue(VectorSizeFieldInfo);
- else
- return getFieldValue(PointerVectorSizeFieldInfo);
- }
+ return SizeInBits;
}
unsigned getAddressSpace() const {
- assert(RawData != 0 && "Invalid Type");
- assert(IsPointer && "cannot get address space of non-pointer type");
- if (!IsVector)
- return getFieldValue(PointerAddressSpaceFieldInfo);
- else
- return getFieldValue(PointerVectorAddressSpaceFieldInfo);
+ assert(isPointer() && "cannot get address space of non-pointer type");
+ return ElementsOrAddrSpace;
}
/// Returns the vector's element type. Only valid for vector types.
LLT getElementType() const {
assert(isVector() && "cannot get element type of scalar/aggregate");
- if (IsPointer)
- return pointer(getAddressSpace(), getScalarSizeInBits());
- else
- return scalar(getScalarSizeInBits());
+ return scalar(SizeInBits);
}
/// Get a low-level type with half the size of the original, by halving the
/// size of the scalar type involved. For example `s32` will become `s16`,
/// `<2 x s32>` will become `<2 x s16>`.
LLT halfScalarSize() const {
- assert(!IsPointer && getScalarSizeInBits() > 1 &&
+ assert(!isPointer() && getScalarSizeInBits() > 1 &&
getScalarSizeInBits() % 2 == 0 && "cannot half size of this type");
- return LLT{/*isPointer=*/false, IsVector ? true : false,
- IsVector ? getNumElements() : (uint16_t)0,
- getScalarSizeInBits() / 2, /*AddressSpace=*/0};
+ return LLT{Kind, ElementsOrAddrSpace, SizeInBits / 2};
}
/// Get a low-level type with twice the size of the original, by doubling the
/// size of the scalar type involved. For example `s32` will become `s64`,
/// `<2 x s32>` will become `<2 x s64>`.
LLT doubleScalarSize() const {
- assert(!IsPointer && "cannot change size of this type");
- return LLT{/*isPointer=*/false, IsVector ? true : false,
- IsVector ? getNumElements() : (uint16_t)0,
- getScalarSizeInBits() * 2, /*AddressSpace=*/0};
+ assert(!isPointer() && "cannot change size of this type");
+ return LLT{Kind, ElementsOrAddrSpace, SizeInBits * 2};
}
/// Get a low-level type with half the size of the original, by halving the
/// a vector type with an even number of elements. For example `<4 x s32>`
/// will become `<2 x s32>`, `<2 x s32>` will become `s32`.
LLT halfElements() const {
- assert(isVector() && getNumElements() % 2 == 0 && "cannot half odd vector");
- if (getNumElements() == 2)
- return scalar(getScalarSizeInBits());
+ assert(isVector() && ElementsOrAddrSpace % 2 == 0 &&
+ "cannot half odd vector");
+ if (ElementsOrAddrSpace == 2)
+ return scalar(SizeInBits);
- return LLT{/*isPointer=*/false, /*isVector=*/true,
- (uint16_t)(getNumElements() / 2), getScalarSizeInBits(),
- /*AddressSpace=*/0};
+ return LLT{Vector, static_cast<uint16_t>(ElementsOrAddrSpace / 2),
+ SizeInBits};
}
/// Get a low-level type with twice the size of the original, by doubling the
/// a vector type. For example `<2 x s32>` will become `<4 x s32>`. Doubling
/// the number of elements in sN produces <2 x sN>.
LLT doubleElements() const {
- return LLT{IsPointer ? true : false, /*isVector=*/true,
- (uint16_t)(getNumElements() * 2), getScalarSizeInBits(),
- IsPointer ? getAddressSpace() : 0};
+ assert(!isPointer() && "cannot double elements in pointer");
+ return LLT{Vector, static_cast<uint16_t>(ElementsOrAddrSpace * 2),
+ SizeInBits};
}
void print(raw_ostream &OS) const;
bool operator==(const LLT &RHS) const {
- return IsPointer == RHS.IsPointer && IsVector == RHS.IsVector &&
- RHS.RawData == RawData;
+ return Kind == RHS.Kind && SizeInBits == RHS.SizeInBits &&
+ ElementsOrAddrSpace == RHS.ElementsOrAddrSpace;
}
bool operator!=(const LLT &RHS) const { return !(*this == RHS); }
friend struct DenseMapInfo<LLT>;
-
private:
- /// LLT is packed into 64 bits as follows:
- /// isPointer : 1
- /// isVector : 1
- /// with 62 bits remaining for Kind-specific data, packed in bitfields
- /// as described below. As there isn't a simple portable way to pack bits
- /// into bitfields, here the different fields in the packed structure is
- /// described in static const *Field variables. Each of these variables
- /// is a 2-element array, with the first element describing the bitfield size
- /// and the second element describing the bitfield offset.
- typedef int BitFieldInfo[2];
- ///
- /// This is how the bitfields are packed per Kind:
- /// * Invalid:
- /// gets encoded as RawData == 0, as that is an invalid encoding, since for
- /// valid encodings, SizeInBits/SizeOfElement must be larger than 0.
- /// * Non-pointer scalar (isPointer == 0 && isVector == 0):
- /// SizeInBits: 32;
- static const constexpr BitFieldInfo ScalarSizeFieldInfo{32, 0};
- /// * Pointer (isPointer == 1 && isVector == 0):
- /// SizeInBits: 16;
- /// AddressSpace: 23;
- static const constexpr BitFieldInfo PointerSizeFieldInfo{16, 0};
- static const constexpr BitFieldInfo PointerAddressSpaceFieldInfo{
- 23, PointerSizeFieldInfo[0] + PointerSizeFieldInfo[1]};
- /// * Vector-of-non-pointer (isPointer == 0 && isVector == 1):
- /// NumElements: 16;
- /// SizeOfElement: 32;
- static const constexpr BitFieldInfo VectorElementsFieldInfo{16, 0};
- static const constexpr BitFieldInfo VectorSizeFieldInfo{
- 32, VectorElementsFieldInfo[0] + VectorElementsFieldInfo[1]};
- /// * Vector-of-pointer (isPointer == 1 && isVector == 1):
- /// NumElements: 16;
- /// SizeOfElement: 16;
- /// AddressSpace: 23;
- static const constexpr BitFieldInfo PointerVectorElementsFieldInfo{16, 0};
- static const constexpr BitFieldInfo PointerVectorSizeFieldInfo{
- 16,
- PointerVectorElementsFieldInfo[1] + PointerVectorElementsFieldInfo[0]};
- static const constexpr BitFieldInfo PointerVectorAddressSpaceFieldInfo{
- 23, PointerVectorSizeFieldInfo[1] + PointerVectorSizeFieldInfo[0]};
-
- uint64_t IsPointer : 1;
- uint64_t IsVector : 1;
- uint64_t RawData : 62;
-
- static uint64_t getMask(const BitFieldInfo FieldInfo) {
- const int FieldSizeInBits = FieldInfo[0];
- return (((uint64_t)1) << FieldSizeInBits) - 1;
- }
- static uint64_t maskAndShift(uint64_t Val, uint64_t Mask, uint8_t Shift) {
- assert(Val <= Mask && "Value too large for field");
- return (Val & Mask) << Shift;
- }
- static uint64_t maskAndShift(uint64_t Val, const BitFieldInfo FieldInfo) {
- return maskAndShift(Val, getMask(FieldInfo), FieldInfo[1]);
- }
- uint64_t getFieldValue(const BitFieldInfo FieldInfo) const {
- return getMask(FieldInfo) & (RawData >> FieldInfo[1]);
- }
-
- void init(bool IsPointer, bool IsVector, uint16_t NumElements,
- unsigned SizeInBits, unsigned AddressSpace) {
- this->IsPointer = IsPointer;
- this->IsVector = IsVector;
- if (!IsVector) {
- if (!IsPointer)
- RawData = maskAndShift(SizeInBits, ScalarSizeFieldInfo);
- else
- RawData = maskAndShift(SizeInBits, PointerSizeFieldInfo) |
- maskAndShift(AddressSpace, PointerAddressSpaceFieldInfo);
- } else {
- assert(NumElements > 1 && "invalid number of vector elements");
- if (!IsPointer)
- RawData = maskAndShift(NumElements, VectorElementsFieldInfo) |
- maskAndShift(SizeInBits, VectorSizeFieldInfo);
- else
- RawData =
- maskAndShift(NumElements, PointerVectorElementsFieldInfo) |
- maskAndShift(SizeInBits, PointerVectorSizeFieldInfo) |
- maskAndShift(AddressSpace, PointerVectorAddressSpaceFieldInfo);
- }
- }
+ unsigned SizeInBits;
+ uint16_t ElementsOrAddrSpace;
+ TypeKind Kind;
};
inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) {
template<> struct DenseMapInfo<LLT> {
static inline LLT getEmptyKey() {
- LLT Invalid;
- Invalid.IsPointer = true;
- return Invalid;
+ return LLT{LLT::Invalid, 0, -1u};
}
static inline LLT getTombstoneKey() {
- LLT Invalid;
- Invalid.IsVector = true;
- return Invalid;
+ return LLT{LLT::Invalid, 0, -2u};
}
static inline unsigned getHashValue(const LLT &Ty) {
- uint64_t Val = ((uint64_t)Ty.RawData) << 2 | ((uint64_t)Ty.IsPointer) << 1 |
- ((uint64_t)Ty.IsVector);
+ uint64_t Val = ((uint64_t)Ty.SizeInBits << 32) |
+ ((uint64_t)Ty.ElementsOrAddrSpace << 16) | (uint64_t)Ty.Kind;
return DenseMapInfo<uint64_t>::getHashValue(Val);
}
static bool isEqual(const LLT &LHS, const LLT &RHS) {
projects / platform / upstream / llvm.git / commitdiff