[llvm] f4e5541 - [Local] Clean up enforceKnownAlignment() (NFC)
Nikita Popov via llvm-commits
llvm-commits at lists.llvm.org
Sat Sep 19 13:29:50 PDT 2020
Author: Nikita Popov
Date: 2020-09-19T22:29:40+02:00
New Revision: f4e554180962aa6bc93678898b6933ea712bde50
URL: https://github.com/llvm/llvm-project/commit/f4e554180962aa6bc93678898b6933ea712bde50
DIFF: https://github.com/llvm/llvm-project/commit/f4e554180962aa6bc93678898b6933ea712bde50.diff
LOG: [Local] Clean up enforceKnownAlignment() (NFC)
I want to export this function, and the current API was a bit
weird: It took an additional Alignment argument that didn't really
have anything to do with what the function does. Drop it, and
perform a max at the callsite.
Also rename it to tryEnforceAlignment().
Added:
Modified:
llvm/lib/Transforms/Utils/Local.cpp
Removed:
################################################################################
diff --git a/llvm/lib/Transforms/Utils/Local.cpp b/llvm/lib/Transforms/Utils/Local.cpp
index 51e8251b2280..0861e99c3e1e 100644
--- a/llvm/lib/Transforms/Utils/Local.cpp
+++ b/llvm/lib/Transforms/Utils/Local.cpp
@@ -1262,54 +1262,53 @@ bool llvm::EliminateDuplicatePHINodes(BasicBlock *BB) {
return EliminateDuplicatePHINodesSetBasedImpl(BB);
}
-/// enforceKnownAlignment - If the specified pointer points to an object that
-/// we control, modify the object's alignment to PrefAlign. This isn't
-/// often possible though. If alignment is important, a more reliable approach
-/// is to simply align all global variables and allocation instructions to
-/// their preferred alignment from the beginning.
-static Align enforceKnownAlignment(Value *V, Align Alignment, Align PrefAlign,
- const DataLayout &DL) {
- assert(PrefAlign > Alignment);
-
+/// If the specified pointer points to an object that we control, try to modify
+/// the object's alignment to PrefAlign. Returns a minimum known alignment of
+/// the value after the operation, which may be lower than PrefAlign.
+///
+/// Increating value alignment isn't often possible though. If alignment is
+/// important, a more reliable approach is to simply align all global variables
+/// and allocation instructions to their preferred alignment from the beginning.
+static Align tryEnforceAlignment(Value *V, Align PrefAlign,
+ const DataLayout &DL) {
V = V->stripPointerCasts();
if (AllocaInst *AI = dyn_cast<AllocaInst>(V)) {
- // TODO: ideally, computeKnownBits ought to have used
- // AllocaInst::getAlignment() in its computation already, making
- // the below max redundant. But, as it turns out,
- // stripPointerCasts recurses through infinite layers of bitcasts,
- // while computeKnownBits is not allowed to traverse more than 6
- // levels.
- Alignment = std::max(AI->getAlign(), Alignment);
- if (PrefAlign <= Alignment)
- return Alignment;
+ // TODO: Ideally, this function would not be called if PrefAlign is smaller
+ // than the current alignment, as the known bits calculation should have
+ // already taken it into account. However, this is not always the case,
+ // as computeKnownBits() has a depth limit, while stripPointerCasts()
+ // doesn't.
+ Align CurrentAlign = AI->getAlign();
+ if (PrefAlign <= CurrentAlign)
+ return CurrentAlign;
// If the preferred alignment is greater than the natural stack alignment
// then don't round up. This avoids dynamic stack realignment.
if (DL.exceedsNaturalStackAlignment(PrefAlign))
- return Alignment;
+ return CurrentAlign;
AI->setAlignment(PrefAlign);
return PrefAlign;
}
if (auto *GO = dyn_cast<GlobalObject>(V)) {
// TODO: as above, this shouldn't be necessary.
- Alignment = max(GO->getAlign(), Alignment);
- if (PrefAlign <= Alignment)
- return Alignment;
+ Align CurrentAlign = GO->getPointerAlignment(DL);
+ if (PrefAlign <= CurrentAlign)
+ return CurrentAlign;
// If there is a large requested alignment and we can, bump up the alignment
// of the global. If the memory we set aside for the global may not be the
// memory used by the final program then it is impossible for us to reliably
// enforce the preferred alignment.
if (!GO->canIncreaseAlignment())
- return Alignment;
+ return CurrentAlign;
GO->setAlignment(PrefAlign);
return PrefAlign;
}
- return Alignment;
+ return Align(1);
}
Align llvm::getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign,
@@ -1331,7 +1330,7 @@ Align llvm::getOrEnforceKnownAlignment(Value *V, MaybeAlign PrefAlign,
Align Alignment = Align(1ull << std::min(Known.getBitWidth() - 1, TrailZ));
if (PrefAlign && *PrefAlign > Alignment)
- Alignment = enforceKnownAlignment(V, Alignment, *PrefAlign, DL);
+ Alignment = std::max(Alignment, tryEnforceAlignment(V, *PrefAlign, DL));
// We don't need to make any adjustment.
return Alignment;
More information about the llvm-commits
mailing list