[llvm] a460c8e - [NFCI][SROA] reduce calls to getAllocatedType() (#177437)
via llvm-commits
llvm-commits at lists.llvm.org
Mon Jan 26 21:04:00 PST 2026
Author: Jameson Nash
Date: 2026-01-27T00:03:55-05:00
New Revision: a460c8e8dafc28fef240fce44dcbed043fe56a71
URL: https://github.com/llvm/llvm-project/commit/a460c8e8dafc28fef240fce44dcbed043fe56a71
DIFF: https://github.com/llvm/llvm-project/commit/a460c8e8dafc28fef240fce44dcbed043fe56a71.diff
LOG: [NFCI][SROA] reduce calls to getAllocatedType() (#177437)
Replace repeated calls with getAllocationSize() and cached NewAllocaTy.
In AllocaSliceRewriter, the allocated type is already stored in the
NewAllocaTy member variable and now passed directly there. This change
replaces the remaining direct calls to `NewAI.getAllocatedType()` with
the cached NewAllocaTy to simplify and DRY the code.
Co-authored-by: Claude Opus 4.5 <noreply at anthropic.com>
Added:
Modified:
llvm/lib/Transforms/Scalar/SROA.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Scalar/SROA.cpp b/llvm/lib/Transforms/Scalar/SROA.cpp
index 9e1f695d4fd97..83eabdae3db7f 100644
--- a/llvm/lib/Transforms/Scalar/SROA.cpp
+++ b/llvm/lib/Transforms/Scalar/SROA.cpp
@@ -252,7 +252,8 @@ class SROA {
friend class AllocaSliceRewriter;
bool presplitLoadsAndStores(AllocaInst &AI, AllocaSlices &AS);
- AllocaInst *rewritePartition(AllocaInst &AI, AllocaSlices &AS, Partition &P);
+ std::pair<AllocaInst *, uint64_t>
+ rewritePartition(AllocaInst &AI, AllocaSlices &AS, Partition &P);
bool splitAlloca(AllocaInst &AI, AllocaSlices &AS);
bool propagateStoredValuesToLoads(AllocaInst &AI, AllocaSlices &AS);
std::pair<bool /*Changed*/, bool /*CFGChanged*/> runOnAlloca(AllocaInst &AI);
@@ -1051,8 +1052,7 @@ class AllocaSlices::SliceBuilder : public PtrUseVisitor<SliceBuilder> {
public:
SliceBuilder(const DataLayout &DL, AllocaInst &AI, AllocaSlices &AS)
: PtrUseVisitor<SliceBuilder>(DL),
- AllocSize(DL.getTypeAllocSize(AI.getAllocatedType()).getFixedValue()),
- AS(AS) {}
+ AllocSize(AI.getAllocationSize(DL)->getFixedValue()), AS(AS) {}
private:
void markAsDead(Instruction &I) {
@@ -2878,7 +2878,7 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
public:
AllocaSliceRewriter(const DataLayout &DL, AllocaSlices &AS, SROA &Pass,
- AllocaInst &OldAI, AllocaInst &NewAI,
+ AllocaInst &OldAI, AllocaInst &NewAI, Type *NewAllocaTy,
uint64_t NewAllocaBeginOffset,
uint64_t NewAllocaEndOffset, bool IsIntegerPromotable,
VectorType *PromotableVecTy,
@@ -2886,14 +2886,12 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
SmallSetVector<SelectInst *, 8> &SelectUsers)
: DL(DL), AS(AS), Pass(Pass), OldAI(OldAI), NewAI(NewAI),
NewAllocaBeginOffset(NewAllocaBeginOffset),
- NewAllocaEndOffset(NewAllocaEndOffset),
- NewAllocaTy(NewAI.getAllocatedType()),
- IntTy(
- IsIntegerPromotable
- ? Type::getIntNTy(NewAI.getContext(),
- DL.getTypeSizeInBits(NewAI.getAllocatedType())
- .getFixedValue())
- : nullptr),
+ NewAllocaEndOffset(NewAllocaEndOffset), NewAllocaTy(NewAllocaTy),
+ IntTy(IsIntegerPromotable
+ ? Type::getIntNTy(
+ NewAI.getContext(),
+ DL.getTypeSizeInBits(NewAllocaTy).getFixedValue())
+ : nullptr),
VecTy(PromotableVecTy),
ElementTy(VecTy ? VecTy->getElementType() : nullptr),
ElementSize(VecTy ? DL.getTypeSizeInBits(ElementTy).getFixedValue() / 8
@@ -3009,8 +3007,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
// If the new alloca is a fixed vector type, we use its element type as the
// allocated element type, otherwise we use i8 as the allocated element
Type *AllocatedEltTy =
- isa<FixedVectorType>(NewAI.getAllocatedType())
- ? cast<FixedVectorType>(NewAI.getAllocatedType())->getElementType()
+ isa<FixedVectorType>(NewAllocaTy)
+ ? cast<FixedVectorType>(NewAllocaTy)->getElementType()
: Type::getInt8Ty(NewAI.getContext());
unsigned AllocatedEltTySize = DL.getTypeSizeInBits(AllocatedEltTy);
@@ -3232,8 +3230,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
unsigned EndIndex = getIndex(NewEndOffset);
assert(EndIndex > BeginIndex && "Empty vector!");
- LoadInst *Load = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "load");
+ LoadInst *Load =
+ IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(), "load");
Load->copyMetadata(LI, {LLVMContext::MD_mem_parallel_loop_access,
LLVMContext::MD_access_group});
@@ -3243,8 +3241,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
Value *rewriteIntegerLoad(LoadInst &LI) {
assert(IntTy && "We cannot insert an integer to the alloca");
assert(!LI.isVolatile());
- Value *V = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "load");
+ Value *V =
+ IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(), "load");
V = convertValue(DL, IRB, V, IntTy);
assert(NewBeginOffset >= NewAllocaBeginOffset && "Out of bounds offset");
uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset;
@@ -3289,9 +3287,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
!LI.isVolatile()))) {
Value *NewPtr =
getPtrToNewAI(LI.getPointerAddressSpace(), LI.isVolatile());
- LoadInst *NewLI = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), NewPtr,
- NewAI.getAlign(), LI.isVolatile(),
- LI.getName());
+ LoadInst *NewLI = IRB.CreateAlignedLoad(
+ NewAllocaTy, NewPtr, NewAI.getAlign(), LI.isVolatile(), LI.getName());
if (LI.isVolatile())
NewLI->setAtomic(LI.getOrdering(), LI.getSyncScopeID());
if (NewLI->isAtomic())
@@ -3397,8 +3394,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
V = convertValue(DL, IRB, V, SliceTy);
// Mix in the existing elements.
- Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "load");
+ Value *Old =
+ IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(), "load");
V = insertVector(IRB, Old, V, BeginIndex, "vec");
}
StoreInst *Store = IRB.CreateAlignedStore(V, &NewAI, NewAI.getAlign());
@@ -3421,8 +3418,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
assert(!SI.isVolatile());
if (DL.getTypeSizeInBits(V->getType()).getFixedValue() !=
IntTy->getBitWidth()) {
- Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "oldload");
+ Value *Old = IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(),
+ "oldload");
Old = convertValue(DL, IRB, Old, IntTy);
assert(BeginOffset >= NewAllocaBeginOffset && "Out of bounds offset");
uint64_t Offset = BeginOffset - NewAllocaBeginOffset;
@@ -3573,8 +3570,7 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
// Record this instruction for deletion.
Pass.DeadInsts.push_back(&II);
- Type *AllocaTy = NewAI.getAllocatedType();
- Type *ScalarTy = AllocaTy->getScalarType();
+ Type *ScalarTy = NewAllocaTy->getScalarType();
const bool CanContinue = [&]() {
if (VecTy || IntTy)
@@ -3588,7 +3584,7 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
return false;
auto *Int8Ty = IntegerType::getInt8Ty(NewAI.getContext());
auto *SrcTy = FixedVectorType::get(Int8Ty, Len);
- return canConvertValue(DL, SrcTy, AllocaTy) &&
+ return canConvertValue(DL, SrcTy, NewAllocaTy) &&
DL.isLegalInteger(DL.getTypeSizeInBits(ScalarTy).getFixedValue());
}();
@@ -3636,8 +3632,8 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
if (NumElements > 1)
Splat = getVectorSplat(Splat, NumElements);
- Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "oldload");
+ Value *Old = IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(),
+ "oldload");
V = insertVector(IRB, Old, Splat, BeginIndex, "vec");
} else if (IntTy) {
// If this is a memset on an alloca where we can widen stores, insert the
@@ -3649,7 +3645,7 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
if (IntTy && (BeginOffset != NewAllocaBeginOffset ||
EndOffset != NewAllocaBeginOffset)) {
- Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
+ Value *Old = IRB.CreateAlignedLoad(NewAllocaTy, &NewAI,
NewAI.getAlign(), "oldload");
Old = convertValue(DL, IRB, Old, IntTy);
uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset;
@@ -3658,7 +3654,7 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
assert(V->getType() == IntTy &&
"Wrong type for an alloca wide integer!");
}
- V = convertValue(DL, IRB, V, AllocaTy);
+ V = convertValue(DL, IRB, V, NewAllocaTy);
} else {
// Established these invariants above.
assert(NewBeginOffset == NewAllocaBeginOffset);
@@ -3666,11 +3662,11 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
V = getIntegerSplat(II.getValue(),
DL.getTypeSizeInBits(ScalarTy).getFixedValue() / 8);
- if (VectorType *AllocaVecTy = dyn_cast<VectorType>(AllocaTy))
+ if (VectorType *AllocaVecTy = dyn_cast<VectorType>(NewAllocaTy))
V = getVectorSplat(
V, cast<FixedVectorType>(AllocaVecTy)->getNumElements());
- V = convertValue(DL, IRB, V, AllocaTy);
+ V = convertValue(DL, IRB, V, NewAllocaTy);
}
Value *NewPtr = getPtrToNewAI(II.getDestAddressSpace(), II.isVolatile());
@@ -3740,10 +3736,9 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
bool EmitMemCpy =
!VecTy && !IntTy &&
(BeginOffset > NewAllocaBeginOffset || EndOffset < NewAllocaEndOffset ||
- SliceSize !=
- DL.getTypeStoreSize(NewAI.getAllocatedType()).getFixedValue() ||
- !DL.typeSizeEqualsStoreSize(NewAI.getAllocatedType()) ||
- !NewAI.getAllocatedType()->isSingleValueType());
+ SliceSize != DL.getTypeStoreSize(NewAllocaTy).getFixedValue() ||
+ !DL.typeSizeEqualsStoreSize(NewAllocaTy) ||
+ !NewAllocaTy->isSingleValueType());
// If we're just going to emit a memcpy, the alloca hasn't changed, and the
// size hasn't been shrunk based on analysis of the viable range, this is
@@ -3867,12 +3862,12 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
Value *Src;
if (VecTy && !IsWholeAlloca && !IsDest) {
- Src = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "load");
+ Src =
+ IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(), "load");
Src = extractVector(IRB, Src, BeginIndex, EndIndex, "vec");
} else if (IntTy && !IsWholeAlloca && !IsDest) {
- Src = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "load");
+ Src =
+ IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(), "load");
Src = convertValue(DL, IRB, Src, IntTy);
uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset;
Src = extractInteger(DL, IRB, Src, SubIntTy, Offset, "extract");
@@ -3888,12 +3883,12 @@ class AllocaSliceRewriter : public InstVisitor<AllocaSliceRewriter, bool> {
}
if (VecTy && !IsWholeAlloca && IsDest) {
- Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "oldload");
+ Value *Old = IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(),
+ "oldload");
Src = insertVector(IRB, Old, Src, BeginIndex, "vec");
} else if (IntTy && !IsWholeAlloca && IsDest) {
- Value *Old = IRB.CreateAlignedLoad(NewAI.getAllocatedType(), &NewAI,
- NewAI.getAlign(), "oldload");
+ Value *Old = IRB.CreateAlignedLoad(NewAllocaTy, &NewAI, NewAI.getAlign(),
+ "oldload");
Old = convertValue(DL, IRB, Old, IntTy);
uint64_t Offset = NewBeginOffset - NewAllocaBeginOffset;
Src = insertInteger(DL, IRB, Old, Src, Offset, "insert");
@@ -5319,8 +5314,8 @@ selectPartitionType(Partition &P, const DataLayout &DL, AllocaInst &AI,
/// appropriate new offsets. It also evaluates how successful the rewrite was
/// at enabling promotion and if it was successful queues the alloca to be
/// promoted.
-AllocaInst *SROA::rewritePartition(AllocaInst &AI, AllocaSlices &AS,
- Partition &P) {
+std::pair<AllocaInst *, uint64_t>
+SROA::rewritePartition(AllocaInst &AI, AllocaSlices &AS, Partition &P) {
const DataLayout &DL = AI.getDataLayout();
// Select the type for the new alloca that spans the partition.
auto [PartitionTy, IsIntegerWideningViable, VecTy] =
@@ -5365,9 +5360,9 @@ AllocaInst *SROA::rewritePartition(AllocaInst &AI, AllocaSlices &AS,
SmallSetVector<PHINode *, 8> PHIUsers;
SmallSetVector<SelectInst *, 8> SelectUsers;
- AllocaSliceRewriter Rewriter(DL, AS, *this, AI, *NewAI, P.beginOffset(),
- P.endOffset(), IsIntegerWideningViable, VecTy,
- PHIUsers, SelectUsers);
+ AllocaSliceRewriter Rewriter(
+ DL, AS, *this, AI, *NewAI, PartitionTy, P.beginOffset(), P.endOffset(),
+ IsIntegerWideningViable, VecTy, PHIUsers, SelectUsers);
bool Promotable = true;
// Check whether we can have tree-structured merge.
if (auto DeletedValues = Rewriter.rewriteTreeStructuredMerge(P)) {
@@ -5446,7 +5441,7 @@ AllocaInst *SROA::rewritePartition(AllocaInst &AI, AllocaSlices &AS,
// We couldn't promote and we didn't create a new partition, nothing
// happened.
if (NewAI == &AI)
- return nullptr;
+ return {nullptr, 0};
// If we can't promote the alloca, iterate on it to check for new
// refinements exposed by splitting the current alloca. Don't iterate on an
@@ -5454,7 +5449,7 @@ AllocaInst *SROA::rewritePartition(AllocaInst &AI, AllocaSlices &AS,
Worklist.insert(NewAI);
}
- return NewAI;
+ return {NewAI, DL.getTypeSizeInBits(PartitionTy).getFixedValue()};
}
// There isn't a shared interface to get the "address" parts out of a
@@ -5633,8 +5628,7 @@ bool SROA::splitAlloca(AllocaInst &AI, AllocaSlices &AS) {
// to be rewritten into a partition.
bool IsSorted = true;
- uint64_t AllocaSize =
- DL.getTypeAllocSize(AI.getAllocatedType()).getFixedValue();
+ uint64_t AllocaSize = AI.getAllocationSize(DL)->getFixedValue();
const uint64_t MaxBitVectorSize = 1024;
if (AllocaSize <= MaxBitVectorSize) {
// If a byte boundary is included in any load or store, a slice starting or
@@ -5693,14 +5687,13 @@ bool SROA::splitAlloca(AllocaInst &AI, AllocaSlices &AS) {
// Rewrite each partition.
for (auto &P : AS.partitions()) {
- if (AllocaInst *NewAI = rewritePartition(AI, AS, P)) {
+ auto [NewAI, ActiveBits] = rewritePartition(AI, AS, P);
+ if (NewAI) {
Changed = true;
if (NewAI != &AI) {
uint64_t SizeOfByte = 8;
- uint64_t AllocaSize =
- DL.getTypeSizeInBits(NewAI->getAllocatedType()).getFixedValue();
// Don't include any padding.
- uint64_t Size = std::min(AllocaSize, P.size() * SizeOfByte);
+ uint64_t Size = std::min(ActiveBits, P.size() * SizeOfByte);
Fragments.push_back(
Fragment(NewAI, P.beginOffset() * SizeOfByte, Size));
}
@@ -5945,10 +5938,8 @@ SROA::runOnAlloca(AllocaInst &AI) {
const DataLayout &DL = AI.getDataLayout();
// Skip alloca forms that this analysis can't handle.
- auto *AT = AI.getAllocatedType();
- TypeSize Size = DL.getTypeAllocSize(AT);
- if (AI.isArrayAllocation() || !AT->isSized() || Size.isScalable() ||
- Size.getFixedValue() == 0)
+ std::optional<TypeSize> Size = AI.getAllocationSize(DL);
+ if (AI.isArrayAllocation() || !Size || Size->isScalable() || Size->isZero())
return {Changed, CFGChanged};
// First, split any FCA loads and stores touching this alloca to promote
@@ -6110,8 +6101,8 @@ std::pair<bool /*Changed*/, bool /*CFGChanged*/> SROA::runSROA(Function &F) {
for (BasicBlock::iterator I = EntryBB.begin(), E = std::prev(EntryBB.end());
I != E; ++I) {
if (AllocaInst *AI = dyn_cast<AllocaInst>(I)) {
- if (DL.getTypeAllocSize(AI->getAllocatedType()).isScalable() &&
- isAllocaPromotable(AI))
+ std::optional<TypeSize> Size = AI->getAllocationSize(DL);
+ if (Size && Size->isScalable() && isAllocaPromotable(AI))
PromotableAllocas.insert(AI);
else
Worklist.insert(AI);
More information about the llvm-commits
mailing list