[llvm] 94abecc - [IVDescriptors] Remove typed pointer support (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Wed Jul 12 06:48:37 PDT 2023
Author: Nikita Popov
Date: 2023-07-12T15:48:29+02:00
New Revision: 94abecca6b908f26a979f50e800284a438d79c4b
URL: https://github.com/llvm/llvm-project/commit/94abecca6b908f26a979f50e800284a438d79c4b
DIFF: https://github.com/llvm/llvm-project/commit/94abecca6b908f26a979f50e800284a438d79c4b.diff
LOG: [IVDescriptors] Remove typed pointer support (NFC)
This also removes the element type from the descriptor, as it is
always i8. The meaning of the step is now the same between
integers and pointers.
Added:
Modified:
llvm/include/llvm/Analysis/IVDescriptors.h
llvm/lib/Analysis/IVDescriptors.cpp
llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/IVDescriptors.h b/llvm/include/llvm/Analysis/IVDescriptors.h
index 42826cd4e660a3..dfa1a119c0790a 100644
--- a/llvm/include/llvm/Analysis/IVDescriptors.h
+++ b/llvm/include/llvm/Analysis/IVDescriptors.h
@@ -309,7 +309,7 @@ class InductionDescriptor {
enum InductionKind {
IK_NoInduction, ///< Not an induction variable.
IK_IntInduction, ///< Integer induction variable. Step = C.
- IK_PtrInduction, ///< Pointer induction var. Step = C / sizeof(elem).
+ IK_PtrInduction, ///< Pointer induction var. Step = C.
IK_FpInduction ///< Floating point induction variable.
};
@@ -369,11 +369,6 @@ class InductionDescriptor {
: Instruction::BinaryOpsEnd;
}
- Type *getElementType() const {
- assert(IK == IK_PtrInduction && "Only pointer induction has element type");
- return ElementType;
- }
-
/// Returns a reference to the type cast instructions in the induction
/// update chain, that are redundant when guarded with a runtime
/// SCEV overflow check.
@@ -385,7 +380,6 @@ class InductionDescriptor {
/// Private constructor - used by \c isInductionPHI.
InductionDescriptor(Value *Start, InductionKind K, const SCEV *Step,
BinaryOperator *InductionBinOp = nullptr,
- Type *ElementType = nullptr,
SmallVectorImpl<Instruction *> *Casts = nullptr);
/// Start value.
@@ -396,9 +390,6 @@ class InductionDescriptor {
const SCEV *Step = nullptr;
// Instruction that advances induction variable.
BinaryOperator *InductionBinOp = nullptr;
- // Element type for pointer induction variables.
- // TODO: This can be dropped once support for typed pointers is removed.
- Type *ElementType = nullptr;
// Instructions used for type-casts of the induction variable,
// that are redundant when guarded with a runtime SCEV overflow check.
SmallVector<Instruction *, 2> RedundantCasts;
diff --git a/llvm/lib/Analysis/IVDescriptors.cpp b/llvm/lib/Analysis/IVDescriptors.cpp
index ce3a70b0492c7e..6c750b7baa402b 100644
--- a/llvm/lib/Analysis/IVDescriptors.cpp
+++ b/llvm/lib/Analysis/IVDescriptors.cpp
@@ -1236,10 +1236,8 @@ RecurrenceDescriptor::getReductionOpChain(PHINode *Phi, Loop *L) const {
InductionDescriptor::InductionDescriptor(Value *Start, InductionKind K,
const SCEV *Step, BinaryOperator *BOp,
- Type *ElementType,
SmallVectorImpl<Instruction *> *Casts)
- : StartValue(Start), IK(K), Step(Step), InductionBinOp(BOp),
- ElementType(ElementType) {
+ : StartValue(Start), IK(K), Step(Step), InductionBinOp(BOp) {
assert(IK != IK_NoInduction && "Not an induction");
// Start value type should match the induction kind and the value
@@ -1265,11 +1263,6 @@ InductionDescriptor::InductionDescriptor(Value *Start, InductionKind K,
InductionBinOp->getOpcode() == Instruction::FSub))) &&
"Binary opcode should be specified for FP induction");
- if (IK == IK_PtrInduction)
- assert(ElementType && "Pointer induction must have element type");
- else
- assert(!ElementType && "Non-pointer induction cannot have element type");
-
if (Casts) {
for (auto &Inst : *Casts) {
RedundantCasts.push_back(Inst);
@@ -1535,49 +1528,13 @@ bool InductionDescriptor::isInductionPHI(
BinaryOperator *BOp =
dyn_cast<BinaryOperator>(Phi->getIncomingValueForBlock(Latch));
D = InductionDescriptor(StartValue, IK_IntInduction, Step, BOp,
- /* ElementType */ nullptr, CastsToIgnore);
+ CastsToIgnore);
return true;
}
assert(PhiTy->isPointerTy() && "The PHI must be a pointer");
- PointerType *PtrTy = cast<PointerType>(PhiTy);
- // Always use i8 element type for opaque pointer inductions.
// This allows induction variables w/non-constant steps.
- if (PtrTy->isOpaque()) {
- D = InductionDescriptor(StartValue, IK_PtrInduction, Step,
- /* BinOp */ nullptr,
- Type::getInt8Ty(PtrTy->getContext()));
- return true;
- }
-
- // Pointer induction should be a constant.
- // TODO: This could be generalized, but should probably just
- // be dropped instead once the migration to opaque ptrs is
- // complete.
- if (!ConstStep)
- return false;
-
- Type *ElementType = PtrTy->getNonOpaquePointerElementType();
- if (!ElementType->isSized())
- return false;
-
- ConstantInt *CV = ConstStep->getValue();
- const DataLayout &DL = Phi->getModule()->getDataLayout();
- TypeSize TySize = DL.getTypeAllocSize(ElementType);
- // TODO: We could potentially support this for scalable vectors if we can
- // prove at compile time that the constant step is always a multiple of
- // the scalable type.
- if (TySize.isZero() || TySize.isScalable())
- return false;
-
- int64_t Size = static_cast<int64_t>(TySize.getFixedValue());
- int64_t CVSize = CV->getSExtValue();
- if (CVSize % Size)
- return false;
- auto *StepValue =
- SE->getConstant(CV->getType(), CVSize / Size, true /* signed */);
- D = InductionDescriptor(StartValue, IK_PtrInduction, StepValue,
- /* BinOp */ nullptr, ElementType);
+ D = InductionDescriptor(StartValue, IK_PtrInduction, Step);
return true;
}
diff --git a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
index 181ef1fd615f02..dcf417e8eee2a5 100644
--- a/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
+++ b/llvm/lib/Transforms/Vectorize/LoopVectorize.cpp
@@ -2458,7 +2458,7 @@ static Value *emitTransformedIndex(IRBuilderBase &B, Value *Index,
return CreateAdd(StartValue, Offset);
}
case InductionDescriptor::IK_PtrInduction: {
- return B.CreateGEP(ID.getElementType(), StartValue, CreateMul(Index, Step));
+ return B.CreateGEP(B.getInt8Ty(), StartValue, CreateMul(Index, Step));
}
case InductionDescriptor::IK_FpInduction: {
assert(!isa<VectorType>(Index->getType()) &&
@@ -9473,7 +9473,7 @@ void VPWidenPointerInductionRecipe::execute(VPTransformState &State) {
Value *NumUnrolledElems =
State.Builder.CreateMul(RuntimeVF, ConstantInt::get(PhiType, State.UF));
Value *InductionGEP = GetElementPtrInst::Create(
- IndDesc.getElementType(), NewPointerPhi,
+ State.Builder.getInt8Ty(), NewPointerPhi,
State.Builder.CreateMul(ScalarStepValue, NumUnrolledElems), "ptr.ind",
InductionLoc);
// Add induction update using an incorrect block temporarily. The phi node
@@ -9499,7 +9499,7 @@ void VPWidenPointerInductionRecipe::execute(VPTransformState &State) {
assert(ScalarStepValue == State.get(getOperand(1), VPIteration(Part, 0)) &&
"scalar step must be the same across all parts");
Value *GEP = State.Builder.CreateGEP(
- IndDesc.getElementType(), NewPointerPhi,
+ State.Builder.getInt8Ty(), NewPointerPhi,
State.Builder.CreateMul(
StartOffset,
State.Builder.CreateVectorSplat(State.VF, ScalarStepValue),
More information about the llvm-commits
mailing list