diff --git a/include/llvm/Support/LowLevelTypeImpl.h b/include/llvm/Support/LowLevelTypeImpl.h index e18e58b7b5b..02df4d806f1 100644 --- a/include/llvm/Support/LowLevelTypeImpl.h +++ b/include/llvm/Support/LowLevelTypeImpl.h @@ -39,123 +39,100 @@ class raw_ostream; 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 @@ -163,13 +140,13 @@ public: /// 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(ElementsOrAddrSpace / 2), + SizeInBits}; } /// Get a low-level type with twice the size of the original, by doubling the @@ -177,105 +154,25 @@ public: /// 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(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; - 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) { @@ -285,18 +182,14 @@ inline raw_ostream& operator<<(raw_ostream &OS, const LLT &Ty) { template<> struct DenseMapInfo { 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::getHashValue(Val); } static bool isEqual(const LLT &LHS, const LLT &RHS) { diff --git a/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp b/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp index 54ef7e5c5a1..8d1a263395a 100644 --- a/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp +++ b/lib/CodeGen/GlobalISel/MachineIRBuilder.cpp @@ -592,7 +592,7 @@ MachineInstrBuilder MachineIRBuilder::buildInsertVectorElement(unsigned Res, LLT EltTy = MRI->getType(Elt); LLT IdxTy = MRI->getType(Idx); assert(ResTy.isVector() && ValTy.isVector() && "invalid operand type"); - assert(IdxTy.isScalar() && "invalid operand type"); + assert(EltTy.isScalar() && IdxTy.isScalar() && "invalid operand type"); assert(ResTy.getNumElements() == ValTy.getNumElements() && "type mismatch"); assert(ResTy.getElementType() == EltTy && "type mismatch"); #endif @@ -612,8 +612,7 @@ MachineInstrBuilder MachineIRBuilder::buildExtractVectorElement(unsigned Res, LLT ValTy = MRI->getType(Val); LLT IdxTy = MRI->getType(Idx); assert(ValTy.isVector() && "invalid operand type"); - assert((ResTy.isScalar() || ResTy.isPointer()) && "invalid operand type"); - assert(IdxTy.isScalar() && "invalid operand type"); + assert(ResTy.isScalar() && IdxTy.isScalar() && "invalid operand type"); assert(ValTy.getElementType() == ResTy && "type mismatch"); #endif diff --git a/lib/CodeGen/LowLevelType.cpp b/lib/CodeGen/LowLevelType.cpp index 1c682e72fa4..c4b9068fa90 100644 --- a/lib/CodeGen/LowLevelType.cpp +++ b/lib/CodeGen/LowLevelType.cpp @@ -21,10 +21,10 @@ using namespace llvm; LLT llvm::getLLTForType(Type &Ty, const DataLayout &DL) { if (auto VTy = dyn_cast(&Ty)) { auto NumElements = VTy->getNumElements(); - LLT ScalarTy = getLLTForType(*VTy->getElementType(), DL); + auto ScalarSizeInBits = VTy->getElementType()->getPrimitiveSizeInBits(); if (NumElements == 1) - return ScalarTy; - return LLT::vector(NumElements, ScalarTy); + return LLT::scalar(ScalarSizeInBits); + return LLT::vector(NumElements, ScalarSizeInBits); } else if (auto PTy = dyn_cast(&Ty)) { return LLT::pointer(PTy->getAddressSpace(), DL.getTypeSizeInBits(&Ty)); } else if (Ty.isSized()) { diff --git a/lib/Support/LowLevelType.cpp b/lib/Support/LowLevelType.cpp index 0ee3f1d0119..4290d69cd19 100644 --- a/lib/Support/LowLevelType.cpp +++ b/lib/Support/LowLevelType.cpp @@ -18,25 +18,25 @@ using namespace llvm; LLT::LLT(MVT VT) { if (VT.isVector()) { - init(/*isPointer=*/false, VT.getVectorNumElements() > 1, - VT.getVectorNumElements(), VT.getVectorElementType().getSizeInBits(), - /*AddressSpace=*/0); + SizeInBits = VT.getVectorElementType().getSizeInBits(); + ElementsOrAddrSpace = VT.getVectorNumElements(); + Kind = ElementsOrAddrSpace == 1 ? Scalar : Vector; } else if (VT.isValid()) { // Aggregates are no different from real scalars as far as GlobalISel is // concerned. - assert(VT.getSizeInBits() != 0 && "invalid zero-sized type"); - init(/*isPointer=*/false, /*isVector=*/false, /*NumElements=*/0, - VT.getSizeInBits(), /*AddressSpace=*/0); + Kind = Scalar; + SizeInBits = VT.getSizeInBits(); + ElementsOrAddrSpace = 1; + assert(SizeInBits != 0 && "invalid zero-sized type"); } else { - IsPointer = false; - IsVector = false; - RawData = 0; + Kind = Invalid; + SizeInBits = ElementsOrAddrSpace = 0; } } void LLT::print(raw_ostream &OS) const { if (isVector()) - OS << "<" << getNumElements() << " x " << getElementType() << ">"; + OS << "<" << ElementsOrAddrSpace << " x s" << SizeInBits << ">"; else if (isPointer()) OS << "p" << getAddressSpace(); else if (isValid()) { @@ -45,12 +45,3 @@ void LLT::print(raw_ostream &OS) const { } else llvm_unreachable("trying to print an invalid type"); } - -const constexpr LLT::BitFieldInfo LLT::ScalarSizeFieldInfo; -const constexpr LLT::BitFieldInfo LLT::PointerSizeFieldInfo; -const constexpr LLT::BitFieldInfo LLT::PointerAddressSpaceFieldInfo; -const constexpr LLT::BitFieldInfo LLT::VectorElementsFieldInfo; -const constexpr LLT::BitFieldInfo LLT::VectorSizeFieldInfo; -const constexpr LLT::BitFieldInfo LLT::PointerVectorElementsFieldInfo; -const constexpr LLT::BitFieldInfo LLT::PointerVectorSizeFieldInfo; -const constexpr LLT::BitFieldInfo LLT::PointerVectorAddressSpaceFieldInfo; diff --git a/lib/Target/AArch64/AArch64RegisterBankInfo.cpp b/lib/Target/AArch64/AArch64RegisterBankInfo.cpp index 6f9021c4a03..20a5979f9b4 100644 --- a/lib/Target/AArch64/AArch64RegisterBankInfo.cpp +++ b/lib/Target/AArch64/AArch64RegisterBankInfo.cpp @@ -482,7 +482,7 @@ AArch64RegisterBankInfo::getInstrMapping(const MachineInstr &MI) const { SmallVector OpRegBankIdx(NumOperands); for (unsigned Idx = 0; Idx < NumOperands; ++Idx) { auto &MO = MI.getOperand(Idx); - if (!MO.isReg() || !MO.getReg()) + if (!MO.isReg()) continue; LLT Ty = MRI.getType(MO.getReg()); @@ -537,7 +537,7 @@ AArch64RegisterBankInfo::getInstrMapping(const MachineInstr &MI) const { InstructionMapping{DefaultMappingID, Cost, nullptr, NumOperands}; SmallVector OpdsMapping(NumOperands); for (unsigned Idx = 0; Idx < NumOperands; ++Idx) { - if (MI.getOperand(Idx).isReg() && MI.getOperand(Idx).getReg()) { + if (MI.getOperand(Idx).isReg()) { auto Mapping = getValueMapping(OpRegBankIdx[Idx], OpSize[Idx]); if (!Mapping->isValid()) return InstructionMapping(); diff --git a/test/CodeGen/AArch64/GlobalISel/arm64-fallback.ll b/test/CodeGen/AArch64/GlobalISel/arm64-fallback.ll index 71ea9d54f64..e40199d82c9 100644 --- a/test/CodeGen/AArch64/GlobalISel/arm64-fallback.ll +++ b/test/CodeGen/AArch64/GlobalISel/arm64-fallback.ll @@ -154,19 +154,3 @@ continue: define fp128 @test_quad_dump() { ret fp128 0xL00000000000000004000000000000000 } - -; FALLBACK-WITH-REPORT-ERR: remark: :0:0: unable to legalize instruction: %vreg0(p0) = G_EXTRACT_VECTOR_ELT %vreg1, %vreg2; (in function: vector_of_pointers_extractelement) -; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for vector_of_pointers_extractelement -; FALLBACK-WITH-REPORT-OUT-LABEL: vector_of_pointers_extractelement: -define void @vector_of_pointers_extractelement() { - %dummy = extractelement <2 x i16*> undef, i32 0 - ret void -} - -; FALLBACK-WITH-REPORT-ERR: remark: :0:0: unable to legalize instruction: %vreg0(<2 x p0>) = G_INSERT_VECTOR_ELT %vreg1, %vreg2, %vreg3; (in function: vector_of_pointers_insertelement -; FALLBACK-WITH-REPORT-ERR: warning: Instruction selection used fallback path for vector_of_pointers_insertelement -; FALLBACK-WITH-REPORT-OUT-LABEL: vector_of_pointers_insertelement: -define void @vector_of_pointers_insertelement() { - %dummy = insertelement <2 x i16*> undef, i16* null, i32 0 - ret void -} diff --git a/unittests/CodeGen/LowLevelTypeTest.cpp b/unittests/CodeGen/LowLevelTypeTest.cpp index 428d6b93f79..67113005a46 100644 --- a/unittests/CodeGen/LowLevelTypeTest.cpp +++ b/unittests/CodeGen/LowLevelTypeTest.cpp @@ -171,7 +171,6 @@ TEST(LowLevelTypeTest, Pointer) { for (unsigned AS : {0U, 1U, 127U, 0xffffU}) { const LLT Ty = LLT::pointer(AS, DL.getPointerSizeInBits(AS)); - const LLT VTy = LLT::vector(4, Ty); // Test kind. ASSERT_TRUE(Ty.isValid()); @@ -180,26 +179,16 @@ TEST(LowLevelTypeTest, Pointer) { ASSERT_FALSE(Ty.isScalar()); ASSERT_FALSE(Ty.isVector()); - ASSERT_TRUE(VTy.isValid()); - ASSERT_TRUE(VTy.isVector()); - ASSERT_TRUE(VTy.getElementType().isPointer()); - // Test addressspace. EXPECT_EQ(AS, Ty.getAddressSpace()); - EXPECT_EQ(AS, VTy.getElementType().getAddressSpace()); // Test equality operators. EXPECT_TRUE(Ty == Ty); EXPECT_FALSE(Ty != Ty); - EXPECT_TRUE(VTy == VTy); - EXPECT_FALSE(VTy != VTy); // Test Type->LLT conversion. Type *IRTy = PointerType::get(IntegerType::get(C, 8), AS); EXPECT_EQ(Ty, getLLTForType(*IRTy, DL)); - Type *IRVTy = - VectorType::get(PointerType::get(IntegerType::get(C, 8), AS), 4); - EXPECT_EQ(VTy, getLLTForType(*IRVTy, DL)); } }