Skip to content

Commit

Permalink
Browse files Browse the repository at this point in the history
[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
  • Loading branch information
gchatelet committed Jun 20, 2022
1 parent 009fe07 commit f125518
Show file tree
Hide file tree
Showing 10 changed files with 21 additions and 50 deletions.
8 changes: 0 additions & 8 deletions llvm/include/llvm/Support/Alignment.h
Expand Up @@ -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) {
Expand Down
7 changes: 4 additions & 3 deletions llvm/lib/LTO/LTO.cpp
Expand Up @@ -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;
}
}
Expand Down
7 changes: 3 additions & 4 deletions llvm/lib/Target/AMDGPU/AMDGPUISelLowering.cpp
Expand Up @@ -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;
Expand Down
8 changes: 3 additions & 5 deletions llvm/lib/Target/AMDGPU/AMDGPUSubtarget.cpp
Expand Up @@ -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;
Expand Down
6 changes: 3 additions & 3 deletions llvm/lib/Target/Hexagon/HexagonVExtract.cpp
Expand Up @@ -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) {
Expand All @@ -131,14 +130,15 @@ bool HexagonVExtract::runOnMachineFunction(MachineFunction &MF) {
return AddrR;
};

MaybeAlign MaxAlign;
for (auto &P : VExtractMap) {
unsigned VecR = P.first;
if (P.second.size() <= VExtractThreshold)
continue;

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,
Expand Down
2 changes: 1 addition & 1 deletion llvm/lib/Target/NVPTX/NVPTXAsmPrinter.cpp
Expand Up @@ -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)) {
Expand Down
7 changes: 4 additions & 3 deletions llvm/lib/Transforms/IPO/AttributorAttributes.cpp
Expand Up @@ -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.
Expand Down
3 changes: 2 additions & 1 deletion llvm/lib/Transforms/Utils/InlineFunction.cpp
Expand Up @@ -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,
Expand Down
2 changes: 1 addition & 1 deletion llvm/lib/Transforms/Utils/MemoryTaggingSupport.cpp
Expand Up @@ -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();

Expand Down
21 changes: 0 additions & 21 deletions llvm/unittests/Support/AlignmentTest.cpp
Expand Up @@ -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());
Expand Down

0 comments on commit f125518

Please sign in to comment.