[llvm] f125518 - [NFC][Alignment] Remove max functions between Align and MaybeAlign
Guillaume Chatelet via llvm-commits
llvm-commits at lists.llvm.org
Mon Jun 20 01:38:08 PDT 2022
Author: Guillaume Chatelet
Date: 2022-06-20T08:37:48Z
New Revision: f1255186c7c4a631c051e05ed12ea79ed091141d
URL: https://github.com/llvm/llvm-project/commit/f1255186c7c4a631c051e05ed12ea79ed091141d
DIFF: https://github.com/llvm/llvm-project/commit/f1255186c7c4a631c051e05ed12ea79ed091141d.diff
LOG: [NFC][Alignment] Remove max functions between Align and MaybeAlign
`llvm::max(Align, MaybeAlign)` and `llvm::max(MaybeAlign, Align)` are
not used often enough to be required. They also make the code more opaque.
Differential Revision: https://reviews.llvm.org/D128121
Added:
Modified:
llvm/include/llvm/Support/Alignment.h
llvm/lib/LTO/LTO.cpp
llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp
llvm/lib/Target/Hexagon/HexagonVExtract.cpp
llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
llvm/lib/Transforms/IPO/AttributorAttributes.cpp
llvm/lib/Transforms/Utils/InlineFunction.cpp
llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp
llvm/unittests/Support/AlignmentTest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Support/Alignment.h b/llvm/include/llvm/Support/Alignment.h
index 6cfb9bf8e40f9..ede17ce0cbcad 100644
--- a/llvm/include/llvm/Support/Alignment.h
+++ b/llvm/include/llvm/Support/Alignment.h
@@ -326,14 +326,6 @@ inline Align operator/(Align Lhs, uint64_t Divisor) {
return Align(Lhs.value() / Divisor);
}
-inline Align max(MaybeAlign Lhs, Align Rhs) {
- return Lhs && *Lhs > Rhs ? *Lhs : Rhs;
-}
-
-inline Align max(Align Lhs, MaybeAlign Rhs) {
- return Rhs && *Rhs > Lhs ? *Rhs : Lhs;
-}
-
#ifndef NDEBUG
// For usage in LLVM_DEBUG macros.
inline std::string DebugStr(const Align &A) {
diff --git a/llvm/lib/LTO/LTO.cpp b/llvm/lib/LTO/LTO.cpp
index 69188a4977ce2..2cb832faa9c04 100644
--- a/llvm/lib/LTO/LTO.cpp
+++ b/llvm/lib/LTO/LTO.cpp
@@ -819,9 +819,10 @@ LTO::addRegularLTO(BitcodeModule BM, ArrayRef<InputFile::Symbol> Syms,
// For now they aren't reported correctly by ModuleSymbolTable.
auto &CommonRes = RegularLTO.Commons[std::string(Sym.getIRName())];
CommonRes.Size = std::max(CommonRes.Size, Sym.getCommonSize());
- MaybeAlign SymAlign(Sym.getCommonAlignment());
- if (SymAlign)
- CommonRes.Align = max(*SymAlign, CommonRes.Align);
+ if (uint32_t SymAlignValue = Sym.getCommonAlignment()) {
+ const Align SymAlign(SymAlignValue);
+ CommonRes.Align = std::max(SymAlign, CommonRes.Align.valueOrOne());
+ }
CommonRes.Prevailing |= Res.Prevailing;
}
}
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
index ae2edbb57a547..269d28c8a7ac3 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
@@ -939,10 +939,9 @@ void AMDGPUTargetLowering::analyzeFormalArgumentsCompute(
const bool IsByRef = Arg.hasByRefAttr();
Type *BaseArgTy = Arg.getType();
Type *MemArgTy = IsByRef ? Arg.getParamByRefType() : BaseArgTy;
- MaybeAlign Alignment = IsByRef ? Arg.getParamAlign() : None;
- if (!Alignment)
- Alignment = DL.getABITypeAlign(MemArgTy);
- MaxAlign = max(Alignment, MaxAlign);
+ Align Alignment = DL.getValueOrABITypeAlignment(
+ IsByRef ? Arg.getParamAlign() : None, MemArgTy);
+ MaxAlign = std::max(Alignment, MaxAlign);
uint64_t AllocSize = DL.getTypeAllocSize(MemArgTy);
uint64_t ArgOffset = alignTo(ExplicitArgOffset, Alignment) + ExplicitOffset;
diff --git a/llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp b/llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp
index 40614f4d37a56..77816a7836306 100644
--- a/llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp
+++ b/llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp
@@ -535,13 +535,11 @@ uint64_t AMDGPUSubtarget::getExplicitKernArgSize(const Function &F,
for (const Argument &Arg : F.args()) {
const bool IsByRef = Arg.hasByRefAttr();
Type *ArgTy = IsByRef ? Arg.getParamByRefType() : Arg.getType();
- MaybeAlign Alignment = IsByRef ? Arg.getParamAlign() : None;
- if (!Alignment)
- Alignment = DL.getABITypeAlign(ArgTy);
-
+ Align Alignment = DL.getValueOrABITypeAlignment(
+ IsByRef ? Arg.getParamAlign() : None, ArgTy);
uint64_t AllocSize = DL.getTypeAllocSize(ArgTy);
ExplicitArgBytes = alignTo(ExplicitArgBytes, Alignment) + AllocSize;
- MaxAlign = max(MaxAlign, Alignment);
+ MaxAlign = std::max(MaxAlign, Alignment);
}
return ExplicitArgBytes;
diff --git a/llvm/lib/Target/Hexagon/HexagonVExtract.cpp b/llvm/lib/Target/Hexagon/HexagonVExtract.cpp
index d93f2352d6e08..845fa1e49578c 100644
--- a/llvm/lib/Target/Hexagon/HexagonVExtract.cpp
+++ b/llvm/lib/Target/Hexagon/HexagonVExtract.cpp
@@ -106,8 +106,7 @@ bool HexagonVExtract::runOnMachineFunction(MachineFunction &MF) {
MachineFrameInfo &MFI = MF.getFrameInfo();
Register AR =
MF.getInfo<HexagonMachineFunctionInfo>()->getStackAlignBaseVReg();
- std::map<unsigned, SmallVector<MachineInstr*,4>> VExtractMap;
- MaybeAlign MaxAlign;
+ std::map<unsigned, SmallVector<MachineInstr *, 4>> VExtractMap;
bool Changed = false;
for (MachineBasicBlock &MBB : MF) {
@@ -131,6 +130,7 @@ bool HexagonVExtract::runOnMachineFunction(MachineFunction &MF) {
return AddrR;
};
+ MaybeAlign MaxAlign;
for (auto &P : VExtractMap) {
unsigned VecR = P.first;
if (P.second.size() <= VExtractThreshold)
@@ -138,7 +138,7 @@ bool HexagonVExtract::runOnMachineFunction(MachineFunction &MF) {
const auto &VecRC = *MRI.getRegClass(VecR);
Align Alignment = HRI.getSpillAlign(VecRC);
- MaxAlign = max(MaxAlign, Alignment);
+ MaxAlign = std::max(MaxAlign.valueOrOne(), Alignment);
// Make sure this is not a spill slot: spill slots cannot be aligned
// if there are variable-sized objects on the stack. They must be
// accessible via FP (which is not aligned), because SP is unknown,
diff --git a/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp b/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
index 3ebfa40df0e2a..b1d8421220607 100644
--- a/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
+++ b/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
@@ -1427,7 +1427,7 @@ void NVPTXAsmPrinter::emitFunctionParamList(const Function *F, raw_ostream &O) {
paramIndex](Type *Ty) -> Align {
Align TypeAlign = TLI->getFunctionParamOptimizedAlign(F, Ty, DL);
MaybeAlign ParamAlign = PAL.getParamAlignment(paramIndex);
- return max(TypeAlign, ParamAlign);
+ return std::max(TypeAlign, ParamAlign.valueOrOne());
};
if (!PAL.hasParamAttr(paramIndex, Attribute::ByVal)) {
diff --git a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
index 19c9191b210b7..cc72b1be76077 100644
--- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
+++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp
@@ -6242,13 +6242,14 @@ struct AAHeapToStackFunction final : public AAHeapToStack {
Align Alignment(1);
if (MaybeAlign RetAlign = AI.CB->getRetAlign())
- Alignment = max(Alignment, RetAlign);
+ Alignment = std::max(Alignment, *RetAlign);
if (Value *Align = getAllocAlignment(AI.CB, TLI)) {
Optional<APInt> AlignmentAPI = getAPInt(A, *this, *Align);
assert(AlignmentAPI.hasValue() &&
+ AlignmentAPI.getValue().getZExtValue() > 0 &&
"Expected an alignment during manifest!");
- Alignment =
- max(Alignment, MaybeAlign(AlignmentAPI.getValue().getZExtValue()));
+ Alignment = std::max(
+ Alignment, assumeAligned(AlignmentAPI.getValue().getZExtValue()));
}
// TODO: Hoist the alloca towards the function entry.
diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp
index 8f88ca24708f5..03cb9e2cc1365 100644
--- a/llvm/lib/Transforms/Utils/InlineFunction.cpp
+++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp
@@ -1421,7 +1421,8 @@ static Value *HandleByValArgument(Type *ByValType, Value *Arg,
// If the byval had an alignment specified, we *must* use at least that
// alignment, as it is required by the byval argument (and uses of the
// pointer inside the callee).
- Alignment = max(Alignment, MaybeAlign(ByValAlignment));
+ if (ByValAlignment > 0)
+ Alignment = std::max(Alignment, Align(ByValAlignment));
Value *NewAlloca =
new AllocaInst(ByValType, DL.getAllocaAddrSpace(), nullptr, Alignment,
diff --git a/llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp b/llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp
index f306abbda2997..071097706050e 100644
--- a/llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp
+++ b/llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp
@@ -148,7 +148,7 @@ uint64_t getAllocaSizeInBytes(const AllocaInst &AI) {
}
void alignAndPadAlloca(memtag::AllocaInfo &Info, llvm::Align Alignment) {
- const Align NewAlignment = max(MaybeAlign(Info.AI->getAlign()), Alignment);
+ const Align NewAlignment = std::max(Info.AI->getAlign(), Alignment);
Info.AI->setAlignment(NewAlignment);
auto &Ctx = Info.AI->getFunction()->getContext();
diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp
index be95f584d7b16..9841e0938a5a3 100644
--- a/llvm/unittests/Support/AlignmentTest.cpp
+++ b/llvm/unittests/Support/AlignmentTest.cpp
@@ -270,27 +270,6 @@ TEST(AlignmentTest, AlignComparisons) {
}
}
-TEST(AlignmentTest, Max) {
- // We introduce std::max here to test ADL.
- using std::max;
-
- // Uses llvm::max.
- EXPECT_EQ(max(MaybeAlign(), Align(2)), Align(2));
- EXPECT_EQ(max(Align(2), MaybeAlign()), Align(2));
-
- EXPECT_EQ(max(MaybeAlign(1), Align(2)), Align(2));
- EXPECT_EQ(max(Align(2), MaybeAlign(1)), Align(2));
-
- EXPECT_EQ(max(MaybeAlign(2), Align(2)), Align(2));
- EXPECT_EQ(max(Align(2), MaybeAlign(2)), Align(2));
-
- EXPECT_EQ(max(MaybeAlign(4), Align(2)), Align(4));
- EXPECT_EQ(max(Align(2), MaybeAlign(4)), Align(4));
-
- // Uses std::max.
- EXPECT_EQ(max(Align(2), Align(4)), Align(4));
-}
-
TEST(AlignmentTest, AssumeAligned) {
EXPECT_EQ(assumeAligned(0), Align(1));
EXPECT_EQ(assumeAligned(0), Align());
More information about the llvm-commits
mailing list