diff --git a/llvm/include/llvm/IR/Value.h b/llvm/include/llvm/IR/Value.h --- a/llvm/include/llvm/IR/Value.h +++ b/llvm/include/llvm/IR/Value.h @@ -664,7 +664,7 @@ /// /// Returns an alignment which is either specified explicitly, e.g. via /// align attribute of a function argument, or guaranteed by DataLayout. - MaybeAlign getPointerAlignment(const DataLayout &DL) const; + Align getPointerAlignment(const DataLayout &DL) const; /// Translate PHI node to its predecessor from the given basic block. /// diff --git a/llvm/lib/Analysis/Loads.cpp b/llvm/lib/Analysis/Loads.cpp --- a/llvm/lib/Analysis/Loads.cpp +++ b/llvm/lib/Analysis/Loads.cpp @@ -27,24 +27,20 @@ using namespace llvm; -static MaybeAlign getBaseAlign(const Value *Base, const DataLayout &DL) { - if (const MaybeAlign PA = Base->getPointerAlignment(DL)) - return *PA; - Type *const Ty = Base->getType()->getPointerElementType(); - if (!Ty->isSized()) - return None; - return Align(DL.getABITypeAlignment(Ty)); -} - static bool isAligned(const Value *Base, const APInt &Offset, Align Alignment, const DataLayout &DL) { - if (MaybeAlign BA = getBaseAlign(Base, DL)) { - const APInt APBaseAlign(Offset.getBitWidth(), BA->value()); - const APInt APAlign(Offset.getBitWidth(), Alignment.value()); - assert(APAlign.isPowerOf2() && "must be a power of 2!"); - return APBaseAlign.uge(APAlign) && !(Offset & (APAlign - 1)); + Align BA = Base->getPointerAlignment(DL); + if (BA == 1 && !isa(Base) && !isa(Base)) { + // If we determined the pointer was unaligned, boost the alignment + // based on the pointer element type. + // FIXME: This seems dubious, but the regression tests expect it. + Type *Ty = Base->getType()->getPointerElementType(); + if (Ty->isSized()) + BA = DL.getABITypeAlign(Ty); } - return false; + const APInt APAlign(Offset.getBitWidth(), Alignment.value()); + assert(APAlign.isPowerOf2() && "must be a power of 2!"); + return BA >= Alignment && !(Offset & (APAlign - 1)); } /// Test if V is always a pointer to allocated and suitably aligned memory for diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -2008,9 +2008,8 @@ // Aligned pointers have trailing zeros - refine Known.Zero set if (isa(V->getType())) { - const MaybeAlign Align = V->getPointerAlignment(Q.DL); - if (Align) - Known.Zero.setLowBits(countTrailingZeros(Align->value())); + Align Alignment = V->getPointerAlignment(Q.DL); + Known.Zero.setLowBits(countTrailingZeros(Alignment.value())); } // computeKnownBitsFromAssume strictly refines Known. diff --git a/llvm/lib/CodeGen/ExpandMemCmp.cpp b/llvm/lib/CodeGen/ExpandMemCmp.cpp --- a/llvm/lib/CodeGen/ExpandMemCmp.cpp +++ b/llvm/lib/CodeGen/ExpandMemCmp.cpp @@ -273,8 +273,8 @@ // Get the memory source at offset `OffsetBytes`. Value *LhsSource = CI->getArgOperand(0); Value *RhsSource = CI->getArgOperand(1); - Align LhsAlign = LhsSource->getPointerAlignment(DL).valueOrOne(); - Align RhsAlign = RhsSource->getPointerAlignment(DL).valueOrOne(); + Align LhsAlign = LhsSource->getPointerAlignment(DL); + Align RhsAlign = RhsSource->getPointerAlignment(DL); if (OffsetBytes > 0) { auto *ByteType = Type::getInt8Ty(CI->getContext()); LhsSource = Builder.CreateConstGEP1_64( diff --git a/llvm/lib/IR/ConstantFold.cpp b/llvm/lib/IR/ConstantFold.cpp --- a/llvm/lib/IR/ConstantFold.cpp +++ b/llvm/lib/IR/ConstantFold.cpp @@ -1210,7 +1210,8 @@ MaybeAlign GVAlign; if (Module *TheModule = GV->getParent()) { - GVAlign = GV->getPointerAlignment(TheModule->getDataLayout()); + const DataLayout &DL = TheModule->getDataLayout(); + GVAlign = GV->getPointerAlignment(DL); // If the function alignment is not specified then assume that it // is 4. @@ -1221,7 +1222,7 @@ // increased code size (see https://reviews.llvm.org/D55115) // FIXME: This code should be deleted once existing targets have // appropriate defaults - if (!GVAlign && isa(GV)) + if (isa(GV) && !DL.getFunctionPtrAlign()) GVAlign = Align(4); } else if (isa(GV)) { // Without a datalayout we have to assume the worst case: that the diff --git a/llvm/lib/IR/Value.cpp b/llvm/lib/IR/Value.cpp --- a/llvm/lib/IR/Value.cpp +++ b/llvm/lib/IR/Value.cpp @@ -738,16 +738,16 @@ return DerefBytes; } -MaybeAlign Value::getPointerAlignment(const DataLayout &DL) const { +Align Value::getPointerAlignment(const DataLayout &DL) const { assert(getType()->isPointerTy() && "must be pointer"); if (auto *GO = dyn_cast(this)) { if (isa(GO)) { - const MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign(); + Align FunctionPtrAlign = DL.getFunctionPtrAlign().valueOrOne(); switch (DL.getFunctionPtrAlignType()) { case DataLayout::FunctionPtrAlignType::Independent: return FunctionPtrAlign; case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign: - return std::max(FunctionPtrAlign, MaybeAlign(GO->getAlignment())); + return std::max(FunctionPtrAlign, GO->getAlign().valueOrOne()); } llvm_unreachable("Unhandled FunctionPtrAlignType"); } @@ -760,13 +760,13 @@ // it the preferred alignment. Otherwise, we have to assume that it // may only have the minimum ABI alignment. if (GVar->isStrongDefinitionForLinker()) - return MaybeAlign(DL.getPreferredAlignment(GVar)); + return Align(DL.getPreferredAlignment(GVar)); else return DL.getABITypeAlign(ObjectType); } } } - return Alignment; + return Alignment.valueOrOne(); } else if (const Argument *A = dyn_cast(this)) { const MaybeAlign Alignment = A->getParamAlign(); if (!Alignment && A->hasStructRetAttr()) { @@ -775,25 +775,18 @@ if (EltTy->isSized()) return DL.getABITypeAlign(EltTy); } - return Alignment; + return Alignment.valueOrOne(); } else if (const AllocaInst *AI = dyn_cast(this)) { - const MaybeAlign Alignment = AI->getAlign(); - if (!Alignment) { - Type *AllocatedType = AI->getAllocatedType(); - if (AllocatedType->isSized()) - return MaybeAlign(DL.getPrefTypeAlignment(AllocatedType)); - } - return Alignment; + return AI->getAlign(); } else if (const auto *Call = dyn_cast(this)) { - const MaybeAlign Alignment = Call->getRetAlign(); + MaybeAlign Alignment = Call->getRetAlign(); if (!Alignment && Call->getCalledFunction()) - return MaybeAlign( - Call->getCalledFunction()->getAttributes().getRetAlignment()); - return Alignment; + Alignment = Call->getCalledFunction()->getAttributes().getRetAlignment(); + return Alignment.valueOrOne(); } else if (const LoadInst *LI = dyn_cast(this)) { if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) { ConstantInt *CI = mdconst::extract(MD->getOperand(0)); - return MaybeAlign(CI->getLimitedValue()); + return Align(CI->getLimitedValue()); } } else if (auto *CstPtr = dyn_cast(this)) { if (auto *CstInt = dyn_cast_or_null(ConstantExpr::getPtrToInt( @@ -807,7 +800,7 @@ : Value::MaximumAlignment); } } - return llvm::None; + return Align(1); } const Value *Value::DoPHITranslation(const BasicBlock *CurBB, diff --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.td b/llvm/lib/Target/AArch64/AArch64InstrInfo.td --- a/llvm/lib/Target/AArch64/AArch64InstrInfo.td +++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.td @@ -2485,8 +2485,8 @@ def alignedglobal : PatLeaf<(iPTR iPTR:$label), [{ if (auto *G = dyn_cast(N)) { const DataLayout &DL = MF->getDataLayout(); - MaybeAlign Align = G->getGlobal()->getPointerAlignment(DL); - return Align && *Align >= 4 && G->getOffset() % 4 == 0; + Align Align = G->getGlobal()->getPointerAlignment(DL); + return Align >= 4 && G->getOffset() % 4 == 0; } if (auto *C = dyn_cast(N)) return C->getAlign() >= 4 && C->getOffset() % 4 == 0; 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 @@ -3523,17 +3523,6 @@ // ------------------------ Align Argument Attribute ------------------------ -/// \p Ptr is accessed so we can get alignment information if the ABI requires -/// the element type to be aligned. -static MaybeAlign getKnownAlignmentFromAccessedPtr(const Value *Ptr, - const DataLayout &DL) { - MaybeAlign KnownAlignment = Ptr->getPointerAlignment(DL); - Type *ElementTy = Ptr->getType()->getPointerElementType(); - if (ElementTy->isSized()) - KnownAlignment = max(KnownAlignment, DL.getABITypeAlign(ElementTy)); - return KnownAlignment; -} - static unsigned getKnownAlignForUse(Attributor &A, AbstractAttribute &QueryingAA, Value &AssociatedValue, const Use *U, @@ -3569,19 +3558,11 @@ const DataLayout &DL = A.getDataLayout(); const Value *UseV = U->get(); if (auto *SI = dyn_cast(I)) { - if (SI->getPointerOperand() == UseV) { - if (unsigned SIAlign = SI->getAlignment()) - MA = MaybeAlign(SIAlign); - else - MA = getKnownAlignmentFromAccessedPtr(UseV, DL); - } + if (SI->getPointerOperand() == UseV) + MA = SI->getAlign(); } else if (auto *LI = dyn_cast(I)) { - if (LI->getPointerOperand() == UseV) { - if (unsigned LIAlign = LI->getAlignment()) - MA = MaybeAlign(LIAlign); - else - MA = getKnownAlignmentFromAccessedPtr(UseV, DL); - } + if (LI->getPointerOperand() == UseV) + MA = LI->getAlign(); } if (!MA.hasValue() || MA <= 1) @@ -3622,8 +3603,7 @@ // their uses and int2ptr is not handled. It is not a correctness // problem though! if (!V.getType()->getPointerElementType()->isFunctionTy()) - takeKnownMaximum( - V.getPointerAlignment(A.getDataLayout()).valueOrOne().value()); + takeKnownMaximum(V.getPointerAlignment(A.getDataLayout()).value()); if (getIRPosition().isFnInterfaceKind() && (!getAnchorScope() || @@ -3664,9 +3644,9 @@ ChangeStatus Changed = AAAlign::manifest(A); - MaybeAlign InheritAlign = + Align InheritAlign = getAssociatedValue().getPointerAlignment(A.getDataLayout()); - if (InheritAlign.valueOrOne() >= getAssumedAlign()) + if (InheritAlign >= getAssumedAlign()) return LoadStoreChanged; return Changed | LoadStoreChanged; } @@ -3717,8 +3697,8 @@ const auto &AA = A.getAAFor(*this, IRPosition::value(V)); if (!Stripped && this == &AA) { // Use only IR information if we did not strip anything. - const MaybeAlign PA = V.getPointerAlignment(DL); - T.takeKnownMaximum(PA ? PA->value() : 0); + Align PA = V.getPointerAlignment(DL); + T.takeKnownMaximum(PA.value()); T.indicatePessimisticFixpoint(); } else { // Use abstract attribute information. @@ -3786,9 +3766,9 @@ if (A.getInfoCache().isInvolvedInMustTailCall(*Arg)) return ChangeStatus::UNCHANGED; ChangeStatus Changed = AAAlignImpl::manifest(A); - MaybeAlign InheritAlign = + Align InheritAlign = getAssociatedValue().getPointerAlignment(A.getDataLayout()); - if (InheritAlign.valueOrOne() >= getAssumedAlign()) + if (InheritAlign >= getAssumedAlign()) Changed = ChangeStatus::UNCHANGED; return Changed; } diff --git a/llvm/unittests/IR/FunctionTest.cpp b/llvm/unittests/IR/FunctionTest.cpp --- a/llvm/unittests/IR/FunctionTest.cpp +++ b/llvm/unittests/IR/FunctionTest.cpp @@ -143,7 +143,7 @@ FunctionType *FuncType(FunctionType::get(VoidType, false)); std::unique_ptr Func(Function::Create( FuncType, GlobalValue::ExternalLinkage)); - EXPECT_EQ(MaybeAlign(), Func->getPointerAlignment(DataLayout(""))); + EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout(""))); EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout("Fi8"))); EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout("Fn8"))); EXPECT_EQ(Align(2), Func->getPointerAlignment(DataLayout("Fi16"))); @@ -153,7 +153,7 @@ Func->setAlignment(Align(4)); - EXPECT_EQ(MaybeAlign(), Func->getPointerAlignment(DataLayout(""))); + EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout(""))); EXPECT_EQ(Align(1), Func->getPointerAlignment(DataLayout("Fi8"))); EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn8"))); EXPECT_EQ(Align(2), Func->getPointerAlignment(DataLayout("Fi16")));