diff --git a/llvm/include/llvm/Support/Alignment.h b/llvm/include/llvm/Support/Alignment.h --- a/llvm/include/llvm/Support/Alignment.h +++ b/llvm/include/llvm/Support/Alignment.h @@ -337,14 +337,6 @@ return Lhs ? Lhs.getValue() / Divisor : MaybeAlign(); } -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 --- a/llvm/lib/LTO/LTO.cpp +++ b/llvm/lib/LTO/LTO.cpp @@ -819,9 +819,10 @@ // 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 --- a/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp @@ -939,10 +939,9 @@ 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 --- a/llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp +++ b/llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp @@ -535,13 +535,11 @@ 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 --- a/llvm/lib/Target/Hexagon/HexagonVExtract.cpp +++ b/llvm/lib/Target/Hexagon/HexagonVExtract.cpp @@ -106,8 +106,7 @@ MachineFrameInfo &MFI = MF.getFrameInfo(); Register AR = MF.getInfo()->getStackAlignBaseVReg(); - std::map> VExtractMap; - MaybeAlign MaxAlign; + std::map> VExtractMap; bool Changed = false; for (MachineBasicBlock &MBB : MF) { @@ -131,6 +130,7 @@ return AddrR; }; + MaybeAlign MaxAlign; for (auto &P : VExtractMap) { unsigned VecR = P.first; if (P.second.size() <= VExtractThreshold) @@ -138,7 +138,7 @@ 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 --- a/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp +++ b/llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp @@ -1427,7 +1427,7 @@ 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 --- a/llvm/lib/Transforms/IPO/AttributorAttributes.cpp +++ b/llvm/lib/Transforms/IPO/AttributorAttributes.cpp @@ -6242,13 +6242,13 @@ 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 AlignmentAPI = getAPInt(A, *this, *Align); assert(AlignmentAPI.hasValue() && "Expected an alignment during manifest!"); - Alignment = - max(Alignment, MaybeAlign(AlignmentAPI.getValue().getZExtValue())); + Alignment = std::max( + Alignment, llvm::Align(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 --- a/llvm/lib/Transforms/Utils/InlineFunction.cpp +++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp @@ -1421,7 +1421,8 @@ // 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 --- a/llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp +++ b/llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp @@ -148,7 +148,7 @@ } 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/tools/llvm-lto2/llvm-lto2.cpp b/llvm/tools/llvm-lto2/llvm-lto2.cpp --- a/llvm/tools/llvm-lto2/llvm-lto2.cpp +++ b/llvm/tools/llvm-lto2/llvm-lto2.cpp @@ -454,7 +454,7 @@ if (Sym.isCommon()) outs() << " size " << Sym.getCommonSize() << " align " - << Sym.getCommonAlignment() << '\n'; + << Sym.getCommonAlignment().value() << '\n'; int Comdat = Sym.getComdatIndex(); if (Comdat != -1) { diff --git a/llvm/unittests/Support/AlignmentTest.cpp b/llvm/unittests/Support/AlignmentTest.cpp --- a/llvm/unittests/Support/AlignmentTest.cpp +++ b/llvm/unittests/Support/AlignmentTest.cpp @@ -272,27 +272,6 @@ } } -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());