Make Value::getPointerAlignment() return an Align, not a MaybeAlign.

[efriedma]

Summary

If we don't know anything about the alignment of a pointer, Align(1) is still correct: all pointers are at least 1-byte aligned.

The changes to Loads.cpp are messy; I'm not sure what the original intent was. It looks like the logic in question originates from D9791.

[jdoerfert]

Everything except the Loads.cpp stuff LGTM.

llvm/lib/Analysis/Loads.cpp

31–32

As you noted, this seems wrong. I think this allows wrong results for llvm::isDereferenceableAndAlignedPointer queries. What happens if you remove this boosting?

---

From D9791:

I assume that pointers without explicit alignment have ABI alignment.

I think this is OK for pointers accessed by loads without specified alignment but not for "pointers" in the general sense. If you look at the AttributorAttributes.cpp change, the function there does something similar to the getBaseAlign on the left but it only does so for pointers accessed without specified alignment. (= I think I came to this conclusion for the second time.)

[efriedma]

Show what happens if I remove the weird special case from Loads.cpp

[efriedma]

llvm/lib/Analysis/Loads.cpp

31–32

The simplest way to show what happens is to just post the patch, so I did that. The issue primarily involves pointers marked with the dereferenceable metadata/attribute; we used to assume they were naturally aligned, but now we don't.

Frontends adding dereferenceable attributes/metadata should also add the corresponding alignment attributes/metadata, but I'm not sure that's actually happening consistently in practice.

[jdoerfert]

llvm/lib/Analysis/Loads.cpp

31–32

I still believe the code was incorrect so I'm in favor of removing it. We might need to improve other places but that seems doable. Let's wait for a while to see if others want to chime in. (@fhahn, @lebedev.ri, @spatel, @nikic, @arsenm, @reames, @nlopes)

[nikic]

llvm/lib/Analysis/Loads.cpp

31–32

Agree that the current behavior is incorrect and we really need to do something about this, because it will block opaque pointers as well.

I think Eli is right though and Clang doesn't emit the necessary alignment attributes here right now, so that probably needs to be addressed first.

[efriedma]

llvm/lib/Analysis/Loads.cpp

31–32

I think D80166 takes care of clang. I can't find any other code that needs to be updated.

[efriedma]

llvm/lib/Analysis/Loads.cpp

31–32

Just merged D80166.

[jdoerfert]

I still think this is the right thing to do and the changes are fine. LGTM. (Let's wait again a little while or until we get another person to look at this.)

Nit: Commit message should be updated. Maybe refer to the clang patch and mention the loads.cpp bug.

[nikic]

LGTM as well.

I'd suggest adding a release note suggesting frontends to make sure they emit align attributes/metadata when emitting dereferenceable attributes/metadata.

llvm/docs/ReleaseNotes.rst

 
 * The callsite attribute `vector-function-abi-variant
   <https://llvm.org/docs/LangRef.html#call-site-attributes>`_ has been
   added to describe the mapping between scalar functions and vector
   functions, to enable vectorization of call sites. The information
   provided by the attribute is interfaced via the API provided by the
   ``VFDatabase`` class.
 
+* `dereferenceable` attributes and metadata on pointers no longer imply
+  anything about the alignment of the pointer in question. Previously, some
+  optimizations would make assumptions based on the type of the pointer. This
+  behavior was undocumented. To preserve optimizations, frontends may need to
+  be updated to generate appropriate `align` attributes and metadata.
+
 Changes to building LLVM
 ------------------------
 
 Changes to the ARM Backend
 --------------------------
 
 During this release ...
 

llvm/include/llvm/IR/Value.h

#include "llvm/IR/Value.def"
   /// dereferenceable up to the returned number of bytes.
   uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
                                           bool &CanBeNull) const;
 
   /// Returns an alignment of the pointer value.
   ///
   /// 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.
   ///
   /// If this value is a PHI node with CurBB as its parent, return the value in
   /// the PHI node corresponding to PredBB.  If not, return ourself.  This is
   /// useful if you want to know the value something has in a predecessor
   /// block.
   const Value *DoPHITranslation(const BasicBlock *CurBB,

llvm/lib/Analysis/Loads.cpp

 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Statepoint.h"
 
 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));
-  }
-  return false;
+  Align BA = Base->getPointerAlignment(DL);
+  return BA >= Alignment && !(Offset & (APAlign - 1));
 }
 
 /// Test if V is always a pointer to allocated and suitably aligned memory for
 /// a simple load or store.
 static bool isDereferenceableAndAlignedPointer(
     const Value *V, Align Alignment, const APInt &Size, const DataLayout &DL,
     const Instruction *CtxI, const DominatorTree *DT,
     SmallPtrSetImpl<const Value *> &Visited, unsigned MaxDepth) {

llvm/lib/Analysis/ValueTracking.cpp

if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
     return;
   }
 
   if (const Operator *I = dyn_cast<Operator>(V))
     computeKnownBitsFromOperator(I, DemandedElts, Known, Depth, Q);
 
   // Aligned pointers have trailing zeros - refine Known.Zero set
   if (isa<PointerType>(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.
   // Therefore, we run them after computeKnownBitsFromOperator.
 
   // Check whether a nearby assume intrinsic can determine some known bits.
   computeKnownBitsFromAssume(V, Known, Depth, Q);
 

llvm/lib/CodeGen/ExpandMemCmp.cpp

 
 MemCmpExpansion::LoadPair MemCmpExpansion::getLoadPair(Type *LoadSizeType,
                                                        bool NeedsBSwap,
                                                        Type *CmpSizeType,
                                                        unsigned OffsetBytes) {
   // 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(
         ByteType, Builder.CreateBitCast(LhsSource, ByteType->getPointerTo()),
         OffsetBytes);
     RhsSource = Builder.CreateConstGEP1_64(
         ByteType, Builder.CreateBitCast(RhsSource, ByteType->getPointerTo()),
         OffsetBytes);

llvm/lib/IR/ConstantFold.cpp

case Instruction::And:
         // If and'ing the address of a global with a constant, fold it.
         if (CE1->getOpcode() == Instruction::PtrToInt &&
             isa<GlobalValue>(CE1->getOperand(0))) {
           GlobalValue *GV = cast<GlobalValue>(CE1->getOperand(0));
 
           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.
             // This is dangerous; on x86, the alignment of the pointer
             // corresponds to the alignment of the function, but might be less
             // than 4 if it isn't explicitly specified.
             // However, a fix for this behaviour was reverted because it
             // increased code size (see https://reviews.llvm.org/D55115)
             // FIXME: This code should be deleted once existing targets have
             // appropriate defaults
-            if (!GVAlign && isa<Function>(GV))
+            if (isa<Function>(GV) && !DL.getFunctionPtrAlign())
               GVAlign = Align(4);
           } else if (isa<Function>(GV)) {
             // Without a datalayout we have to assume the worst case: that the
             // function pointer isn't aligned at all.
             GVAlign = llvm::None;
           } else {
             GVAlign = MaybeAlign(GV->getAlignment());
           }

llvm/lib/IR/Value.cpp

if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
       // CanBeNull flag.
       DerefBytes = DL.getTypeStoreSize(GV->getValueType()).getFixedSize();
       CanBeNull = false;
     }
   }
   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<GlobalObject>(this)) {
     if (isa<Function>(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");
     }
     const MaybeAlign Alignment(GO->getAlignment());
     if (!Alignment) {
       if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
         Type *ObjectType = GVar->getValueType();
         if (ObjectType->isSized()) {
           // If the object is defined in the current Module, we'll be giving
           // 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<Argument>(this)) {
     const MaybeAlign Alignment = A->getParamAlign();
     if (!Alignment && A->hasStructRetAttr()) {
       // An sret parameter has at least the ABI alignment of the return type.
       Type *EltTy = cast<PointerType>(A->getType())->getElementType();
       if (EltTy->isSized())
         return DL.getABITypeAlign(EltTy);
     }
-    return Alignment;
+    return Alignment.valueOrOne();
   } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(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<CallBase>(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<LoadInst>(this)) {
     if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
       ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
-      return MaybeAlign(CI->getLimitedValue());
+      return Align(CI->getLimitedValue());
     }
   } else if (auto *CstPtr = dyn_cast<Constant>(this)) {
     if (auto *CstInt = dyn_cast_or_null<ConstantInt>(ConstantExpr::getPtrToInt(
             const_cast<Constant *>(CstPtr), DL.getIntPtrType(getType()),
             /*OnlyIfReduced=*/true))) {
       size_t TrailingZeros = CstInt->getValue().countTrailingZeros();
       // While the actual alignment may be large, elsewhere we have
       // an arbitrary upper alignmet limit, so let's clamp to it.
       return Align(TrailingZeros < Value::MaxAlignmentExponent
                        ? uint64_t(1) << TrailingZeros
                        : Value::MaximumAlignment);
     }
   }
-  return llvm::None;
+  return Align(1);
 }
 
 const Value *Value::DoPHITranslation(const BasicBlock *CurBB,
                                      const BasicBlock *PredBB) const {
   auto *PN = dyn_cast<PHINode>(this);
   if (PN && PN->getParent() == CurBB)
     return PN->getIncomingValueForBlock(PredBB);
   return this;

llvm/lib/Target/AArch64/AArch64InstrInfo.td

 def : InstAlias<"prfm $Rt, [$Rn]", (PRFMui prfop:$Rt, GPR64sp:$Rn, 0)>;
 
 //---
 // (literal)
 
 def alignedglobal : PatLeaf<(iPTR iPTR:$label), [{
   if (auto *G = dyn_cast<GlobalAddressSDNode>(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<ConstantPoolSDNode>(N))
     return C->getAlign() >= 4 && C->getOffset() % 4 == 0;
   return false;
 }]>;
 
 def LDRWl : LoadLiteral<0b00, 0, GPR32z, "ldr",
   [(set GPR32z:$Rt, (load (AArch64adr alignedglobal:$label)))]>;

llvm/lib/Transforms/IPO/AttributorAttributes.cpp

struct AADereferenceableCallSiteReturned final
   /// See AbstractAttribute::trackStatistics()
   void trackStatistics() const override {
     STATS_DECLTRACK_CS_ATTR(dereferenceable);
   }
 };
 
 // ------------------------ 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,
                                     const Instruction *I, bool &TrackUse) {
   // We need to follow common pointer manipulation uses to the accesses they
   // feed into.
   if (isa<CastInst>(I)) {
     // Follow all but ptr2int casts.
if (const auto *CB = dyn_cast<CallBase>(I)) {
     auto &AlignAA = A.getAAFor<AAAlign>(QueryingAA, IRP,
                                         /* TrackDependence */ false);
     MA = MaybeAlign(AlignAA.getKnownAlign());
   }
 
   const DataLayout &DL = A.getDataLayout();
   const Value *UseV = U->get();
   if (auto *SI = dyn_cast<StoreInst>(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<LoadInst>(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)
     return 0;
 
   unsigned Alignment = MA->value();
   int64_t Offset;
 
void initialize(Attributor &A) override {
 
     Value &V = getAssociatedValue();
     // TODO: This is a HACK to avoid getPointerAlignment to introduce a ptr2int
     //       use of the function pointer. This was caused by D73131. We want to
     //       avoid this for function pointers especially because we iterate
     //       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() ||
          !A.isFunctionIPOAmendable(*getAssociatedFunction()))) {
       indicatePessimisticFixpoint();
       return;
     }
 
for (const Use &U : AssociatedValue.uses()) {
                             "Number of times alignment added to a load");
             LoadStoreChanged = ChangeStatus::CHANGED;
           }
       }
     }
 
     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;
   }
 
   // TODO: Provide a helper to determine the implied ABI alignment and check in
   //       the existing manifest method and a new one for AAAlignImpl that value
   //       to avoid making the alignment explicit if it did not improve.
 
struct AAAlignFloating : AAAlignImpl {
   ChangeStatus updateImpl(Attributor &A) override {
     const DataLayout &DL = A.getDataLayout();
 
     auto VisitValueCB = [&](Value &V, const Instruction *,
                             AAAlign::StateType &T, bool Stripped) -> bool {
       const auto &AA = A.getAAFor<AAAlign>(*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.
         const AAAlign::StateType &DS =
             static_cast<const AAAlign::StateType &>(AA.getState());
         T ^= DS;
       }
       return T.isValidState();
struct AAAlignCallSiteArgument final : AAAlignFloating {
   ChangeStatus manifest(Attributor &A) override {
     // If the associated argument is involved in a must-tail call we give up
     // because we would need to keep the argument alignments of caller and
     // callee in-sync. Just does not seem worth the trouble right now.
     if (Argument *Arg = getAssociatedArgument())
       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;
   }
 
   /// See AbstractAttribute::updateImpl(Attributor &A).
   ChangeStatus updateImpl(Attributor &A) override {
     ChangeStatus Changed = AAAlignFloating::updateImpl(A);
     if (Argument *Arg = getAssociatedArgument()) {

llvm/test/Analysis/ValueTracking/memory-dereferenceable.ll

 ; CHECK: %sret_gep{{.*}}(aligned)
     %sret_gep = getelementptr inbounds %struct.A, %struct.A* %result, i64 0, i32 1, i64 2
     load i8, i8* %sret_gep
 
 ; CHECK-NOT: %sret_gep_outside
     %sret_gep_outside = getelementptr %struct.A, %struct.A* %result, i64 0, i32 1, i64 7
     load i8, i8* %sret_gep_outside
 
-; CHECK: %dparam{{.*}}(aligned)
+; CHECK: %dparam{{.*}}(unaligned)
     %load3 = load i32, i32 addrspace(1)* %dparam
 
-; CHECK: %relocate{{.*}}(aligned)
+; CHECK: %relocate{{.*}}(unaligned)
     %tok = tail call token (i64, i32, i1 ()*, i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 ()* @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam)
     %relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(token %tok, i32 7, i32 7)
     %load4 = load i32, i32 addrspace(1)* %relocate
 
 ; CHECK-NOT: %nparam
     %dpa = call i32 addrspace(1)* @func1(i32 addrspace(1)* %dparam)
     %nparam = getelementptr i32, i32 addrspace(1)* %dpa, i32 5
     %load5 = load i32, i32 addrspace(1)* %nparam
 
     ; Load from a non-dereferenceable load
 ; CHECK-NOT: %nd_load
     %nd_load = load i32*, i32** @globali32ptr
     %load6 = load i32, i32* %nd_load
 
     ; Load from a dereferenceable load
-; CHECK: %d4_load{{.*}}(aligned)
+; CHECK: %d4_load{{.*}}(unaligned)
     %d4_load = load i32*, i32** @globali32ptr, !dereferenceable !0
     %load7 = load i32, i32* %d4_load
 
     ; Load from an offset not covered by the dereferenceable portion
 ; CHECK-NOT: %d2_load
     %d2_load = load i32*, i32** @globali32ptr, !dereferenceable !1
     %load8 = load i32, i32* %d2_load
 
     ; Load from a potentially null pointer with dereferenceable_or_null
 ; CHECK-NOT: %d_or_null_load
     %d_or_null_load = load i32*, i32** @globali32ptr, !dereferenceable_or_null !0
     %load9 = load i32, i32* %d_or_null_load
 
     ; Load from a non-null pointer with dereferenceable_or_null
-; CHECK: %d_or_null_non_null_load{{.*}}(aligned)
+; CHECK: %d_or_null_non_null_load{{.*}}(unaligned)
     %d_or_null_non_null_load = load i32*, i32** @globali32ptr, !nonnull !2, !dereferenceable_or_null !0
     %load10 = load i32, i32* %d_or_null_non_null_load
 
     ; It's OK to overrun static array size as long as we stay within underlying object size
 ; CHECK: %within_allocation{{.*}}(aligned)
     %within_allocation = getelementptr inbounds %struct.A, %struct.A* @globalstruct, i64 0, i32 0, i64 10
     %load11 = load i8, i8* %within_allocation
 

llvm/test/Transforms/GVN/PRE/load-pre-licm.ll

 ; CHECK-LABEL: header
 ; CHECK: load i32, i32* %p
   call void (i1, ...) @llvm.experimental.guard(i1 %cnd) ["deopt"()]
   %v1 = load i32, i32* %p
   call void @hold(i32 %v1)
   br label %header
 }
 
-define i32 @test6b(i1 %cnd, i32* dereferenceable(8) %p) {
+define i32 @test6b(i1 %cnd, i32* dereferenceable(8) align 4 %p) {
 entry: 
 ; CHECK-LABEL: @test6b
 ; CHECK: load i32, i32* %p
   br label %header
 
 header:
 ; CHECK-LABEL: header
   call void (i1, ...) @llvm.experimental.guard(i1 %cnd) ["deopt"()]
   %v1 = load i32, i32* %p
   call void @hold(i32 %v1)
   br label %header
 }

llvm/test/Transforms/GVN/PRE/pre-load.ll

follow_2:
   %vv = load i32, i32* %x, align 4
   ret i32 %vv
 }
 
 ; Same as test13, but %x here is dereferenceable. A pointer that is
 ; dereferenceable can be loaded from speculatively without a risk of trapping.
 ; Since it is OK to speculate, PRE is allowed.
 
-define i32 @test15(i32* noalias nocapture readonly dereferenceable(8) %x, i32* noalias nocapture %r, i32 %a) {
+define i32 @test15(i32* noalias nocapture readonly dereferenceable(8) align 4 %x, i32* noalias nocapture %r, i32 %a) {
 
 ; CHECK-LABEL: @test15
 ; CHECK: entry:
 ; CHECK-NEXT: icmp eq
 ; CHECK-NEXT: br i1
 
 entry:
   %tobool = icmp eq i32 %a, 0

 ; CHECK-NEXT: ret i32 %vv
 
 }
 
 ; Same as test14, but %x here is dereferenceable. A pointer that is
 ; dereferenceable can be loaded from speculatively without a risk of trapping.
 ; Since it is OK to speculate, PRE is allowed.
 
-define i32 @test16(i32* noalias nocapture readonly dereferenceable(8) %x, i32* noalias nocapture %r, i32 %a) {
+define i32 @test16(i32* noalias nocapture readonly dereferenceable(8) align 4 %x, i32* noalias nocapture %r, i32 %a) {
 
 ; CHECK-LABEL: @test16(
 ; CHECK: entry:
 ; CHECK-NEXT: icmp eq
 ; CHECK-NEXT: br i1
 
 entry:
   %tobool = icmp eq i32 %a, 0

llvm/test/Transforms/InstCombine/call-guard.ll

; CHECK:    @llvm.experimental.guard
   %A = icmp slt i32 %V1, 0
   call void(i1, ...) @llvm.experimental.guard( i1 %A, i32 123 )[ "deopt"() ]
   %V2 = load i32, i32* %P
   %B = icmp slt i32 %V2, 0
   call void(i1, ...) @llvm.experimental.guard( i1 %B, i32 456 )[ "deopt"() ]
   ret void
 }
 
-define void @deref_load(i32 %V1, i32* dereferenceable(4) %P) {
+define void @deref_load(i32 %V1, i32* dereferenceable(4) align 4 %P) {
 ; CHECK-LABEL: @deref_load
 ; CHECK-NEXT:  %V2 = load i32, i32* %P, align 4
 ; CHECK-NEXT:  %1 = and i32 %V2, %V1
 ; CHECK-NEXT:  %2 = icmp slt i32 %1, 0
 ; CHECK-NEXT:  call void (i1, ...) @llvm.experimental.guard(i1 %2, i32 123) [ "deopt"() ]
   %A = icmp slt i32 %V1, 0
   call void(i1, ...) @llvm.experimental.guard( i1 %A, i32 123 )[ "deopt"() ]
   %V2 = load i32, i32* %P

llvm/test/Transforms/InstCombine/masked_intrinsics.ll

 ;
   <2 x i1> %mask)  {
   %ptv1 = insertelement <2 x double> undef, double %pt, i64 0
   %ptv2 = insertelement <2 x double> %ptv1, double %pt, i64 1
   %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %ptr, i32 4, <2 x i1> %mask, <2 x double> %ptv2)
   ret <2 x double> %res
 }
 
-define <2 x double> @load_speculative(<2 x double>* dereferenceable(16) %ptr,
+define <2 x double> @load_speculative(<2 x double>* dereferenceable(16) align 4 %ptr,
 ; CHECK-LABEL: @load_speculative(
 ; CHECK-NEXT:    [[PTV1:%.*]] = insertelement <2 x double> undef, double [[PT:%.*]], i64 0
 ; CHECK-NEXT:    [[PTV2:%.*]] = shufflevector <2 x double> [[PTV1]], <2 x double> undef, <2 x i32> zeroinitializer
 ; CHECK-NEXT:    [[UNMASKEDLOAD:%.*]] = load <2 x double>, <2 x double>* [[PTR:%.*]], align 4
 ; CHECK-NEXT:    [[TMP1:%.*]] = select <2 x i1> [[MASK:%.*]], <2 x double> [[UNMASKEDLOAD]], <2 x double> [[PTV2]]
 ; CHECK-NEXT:    ret <2 x double> [[TMP1]]
 ;
   double %pt, <2 x i1> %mask)  {

llvm/test/Transforms/InstCombine/select.ll

entry:
   store i32 42, i32* %z
   %p = select i1 %flag, i32* %x, i32* %y
   %v = load i32, i32* %p
   ret i32 %v
 }
 
 ; Test that we can speculate the loads around the select even when we can't
 ; fold the load completely away.
-define i32 @test78_deref(i1 %flag, i32* dereferenceable(4) %x, i32* dereferenceable(4) %y, i32* %z) {
+define i32 @test78_deref(i1 %flag, i32* dereferenceable(4) align 4 %x, i32* dereferenceable(4) align 4 %y, i32* %z) {
 ; CHECK-LABEL: @test78_deref(
 ; CHECK-NEXT:    [[X_VAL:%.*]] = load i32, i32* [[X:%.*]], align 4
 ; CHECK-NEXT:    [[Y_VAL:%.*]] = load i32, i32* [[Y:%.*]], align 4
 ; CHECK-NEXT:    [[V:%.*]] = select i1 [[FLAG:%.*]], i32 [[X_VAL]], i32 [[Y_VAL]]
 ; CHECK-NEXT:    ret i32 [[V]]
 ;
   %p = select i1 %flag, i32* %x, i32* %y
   %v = load i32, i32* %p

llvm/test/Transforms/LICM/hoist-deref-load.ll

 ; }
 ; and we want to hoist the load of %c out of the loop. This can be done only
 ; because the dereferenceable attribute is on %c.
 
 ; CHECK-LABEL: @test1
 ; CHECK: load i32, i32* %c, align 4
 ; CHECK: for.body:
 
-define void @test1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* nocapture readonly nonnull dereferenceable(4) %c, i32 %n) #0 {
+define void @test1(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* nocapture readonly nonnull dereferenceable(4) align 4 %c, i32 %n) #0 {
 entry:
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.inc
   %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
   %0 = load i32, i32* %arrayidx, align 4

 ; }
 ; and we want to hoist the load of c[2] out of the loop. This can be done only
 ; because the dereferenceable attribute is on %c.
 
 ; CHECK-LABEL: @test3
 ; CHECK: load i32, i32* %c2, align 4
 ; CHECK: for.body:
 
-define void @test3(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* nocapture readonly dereferenceable(12) %c, i32 %n) #0 {
+define void @test3(i32* noalias nocapture %a, i32* noalias nocapture readonly %b, i32* nocapture readonly dereferenceable(12) align 4 %c, i32 %n) #0 {
 entry:
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.inc
   %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
   %0 = load i32, i32* %arrayidx, align 4

 ; and we want to hoist the load of %c out of the loop. This can be done only
 ; because the dereferenceable_or_null attribute is on %c and there is a null
 ; check on %c.
 
 ; CHECK-LABEL: @test5
 ; CHECK: load i32, i32* %c, align 4
 ; CHECK: for.body:
 
-define void @test5(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) %c, i32 %n) #0 {
+define void @test5(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) align 4 %c, i32 %n) #0 {
 entry:
   %not_null = icmp ne i32* %c, null
   br i1 %not_null, label %not.null, label %for.end
 
 not.null:
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end
 

 ; because the dereferenceable meatdata on the c = *cptr load.
 
 ; CHECK-LABEL: @test7
 ; CHECK: load i32, i32* %c, align 4
 ; CHECK: for.body:
 
 define void @test7(i32* noalias %a, i32* %b, i32** %cptr, i32 %n) #0 {
 entry:
-  %c = load i32*, i32** %cptr, !dereferenceable !0
+  %c = load i32*, i32** %cptr, !dereferenceable !0, !align !{i64 4}
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.inc
   %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
   %0 = load i32, i32* %arrayidx, align 4
   %cmp1 = icmp sgt i32 %0, 0

 ; is a null check on %c.
 
 ; CHECK-LABEL: @test8
 ; CHECK: load i32, i32* %c, align 4
 ; CHECK: for.body:
 
 define void @test8(i32* noalias %a, i32* %b, i32** %cptr, i32 %n) #0 {
 entry:
-  %c = load i32*, i32** %cptr, !dereferenceable_or_null !0
+  %c = load i32*, i32** %cptr, !dereferenceable_or_null !0, !align !{i64 4}
   %not_null = icmp ne i32* %c, null
   br i1 %not_null, label %not.null, label %for.end
 
 not.null:
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end
 
 for.body:                                         ; preds = %not.null, %for.inc

 ; after hoisting an instruction.
 
 ; CHECK-LABEL: @test10
 ; CHECK: %c = load i32*, i32** %cptr
 ; CHECK-NOT: dereferenceable
 ; CHECK: if.then:
 ; CHECK: load i32, i32* %c, align 4
 
-define void @test10(i32* noalias %a, i32* %b, i32** dereferenceable(8) %cptr, i32 %n) #0 {
+define void @test10(i32* noalias %a, i32* %b, i32** dereferenceable(8) align 8 %cptr, i32 %n) #0 {
 entry:
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end
 
 for.body:                                         ; preds = %entry, %for.inc
   %indvars.iv = phi i64 [ %indvars.iv.next, %for.inc ], [ 0, %entry ]
   %arrayidx = getelementptr inbounds i32, i32* %a, i64 %indvars.iv
   %0 = load i32, i32* %arrayidx, align 4
for.inc:                                          ; preds = %for.body, %if.then
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.inc, %entry
   ret void
 }
 
 declare void @llvm.experimental.guard(i1, ...)
 
-define void @test12(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) %c, i32 %n) #0 {
+define void @test12(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) align 4 %c, i32 %n) #0 {
 ; Prove non-null ness of %c via a guard, not a branch.
 
 ; CHECK-LABEL: @test12(
 entry:
   %not_null = icmp ne i32* %c, null
   call void(i1, ...) @llvm.experimental.guard(i1 %not_null) [ "deopt"() ]
   %cmp11 = icmp sgt i32 %n, 0
   br i1 %cmp11, label %for.body, label %for.end

 
 for.end:                                          ; preds = %for.inc, %entry, %entry
   call void(i1, ...) @llvm.experimental.guard(i1 %not_null) [ "deopt"() ]
   ret void
 }
 
 ; Check that branch by condition "null check AND something" allows to hoist the
 ; load.
-define void @test14(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) %c, i32 %n, i1 %dummy_cond) #0 {
+define void @test14(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) align 4 %c, i32 %n, i1 %dummy_cond) #0 {
 
 ; CHECK-LABEL: @test14
 ; CHECK: load i32, i32* %c, align 4
 ; CHECK: for.body:
 
 entry:
   %not_null = icmp ne i32* %c, null
   %dummy_and = and i1 %not_null, %dummy_cond
for.inc:                                          ; preds = %for.body, %if.then
   br i1 %exitcond, label %for.end, label %for.body
 
 for.end:                                          ; preds = %for.inc, %entry, %not.null
   ret void
 }
 
 ; Check that guard by condition "null check AND something" allows to hoist the
 ; load.
-define void @test15(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) %c, i32 %n, i1 %dummy_cond) #0 {
+define void @test15(i32* noalias %a, i32* %b, i32* dereferenceable_or_null(4) align 4 %c, i32 %n, i1 %dummy_cond) #0 {
 
 ; CHECK-LABEL: @test15
 ; CHECK: load i32, i32* %c, align 4
 ; CHECK: for.body:
 
 entry:
   %not_null = icmp ne i32* %c, null
   %dummy_and = and i1 %not_null, %dummy_cond

llvm/test/Transforms/SimplifyCFG/SpeculativeExec.ll

end:
   %x7 = phi i8* [ %a, %entry ], [ %b, %if ], [ inttoptr (i64 7 to i8*), %then ]
   %x8 = phi i8* [ %a, %entry ], [ %b, %if ], [ inttoptr (i64 8 to i8*), %then ]
   %x9 = phi i8* [ %a, %entry ], [ %b, %if ], [ inttoptr (i64 9 to i8*), %then ]
   %x10 = phi i8* [ %a, %entry ], [ %b, %if ], [ inttoptr (i64 10 to i8*), %then ]
 
   ret i8* %x10
 }
 
-define i32* @test5(i32 %a, i32 %b, i32 %c, i32* dereferenceable(10) %ptr1, i32* dereferenceable(10) %ptr2, i32** dereferenceable(10) %ptr3) {
+define i32* @test5(i32 %a, i32 %b, i32 %c, i32* dereferenceable(10) %ptr1, i32* dereferenceable(10) %ptr2, i32** dereferenceable(10) align 8 %ptr3) {
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:  entry:
 ; CHECK-NEXT:    [[T1:%.*]] = icmp eq i32 [[B:%.*]], 0
 ; CHECK-NEXT:    br i1 [[T1]], label [[BB1:%.*]], label [[BB3:%.*]]
 ; CHECK:       bb1:
 ; CHECK-NEXT:    [[T2:%.*]] = icmp sgt i32 [[C:%.*]], 1
 ; CHECK-NEXT:    [[T3:%.*]] = load i32*, i32** [[PTR3:%.*]]
 ; CHECK-NEXT:    [[SPEC_SELECT:%.*]] = select i1 [[T2]], i32* [[T3]], i32* [[PTR2:%.*]]

llvm/test/Transforms/TailCallElim/reorder_load.ll

recurse:    ; preds = %else
   %tmp8 = call fastcc i32 @raise_load_4(i32* %a_arg, i32 %first, i32 %tmp7)    ; <i32> [#uses=1]
   %second = load i32, i32* %a_arg    ; <i32> [#uses=1]
   %tmp10 = add i32 %second, %tmp8   ; <i32> [#uses=1]
   ret i32 %tmp10
 }
 
 ; This load can be moved above the call because the function won't write to it
 ; and the a_arg is dereferenceable.
-define fastcc i32 @raise_load_5(i32* dereferenceable(4) %a_arg, i32 %a_len_arg, i32 %start_arg) readonly {
+define fastcc i32 @raise_load_5(i32* dereferenceable(4) align 4 %a_arg, i32 %a_len_arg, i32 %start_arg) readonly {
 ; CHECK-LABEL: @raise_load_5(
 ; CHECK-NOT: call
 ; CHECK: load i32, i32*
 ; CHECK-NOT: call
 ; CHECK: }
 entry:
   %tmp2 = icmp sge i32 %start_arg, %a_len_arg    ; <i1> [#uses=1]
   br i1 %tmp2, label %if, label %else

llvm/unittests/IR/FunctionTest.cpp

 }
 
 TEST(FunctionTest, GetPointerAlignment) {
   LLVMContext Context;
   Type *VoidType(Type::getVoidTy(Context));
   FunctionType *FuncType(FunctionType::get(VoidType, false));
   std::unique_ptr<Function> 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")));
   EXPECT_EQ(Align(2), Func->getPointerAlignment(DataLayout("Fn16")));
   EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fi32")));
   EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn32")));
 
   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")));
   EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn16")));
   EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fi32")));
   EXPECT_EQ(Align(4), Func->getPointerAlignment(DataLayout("Fn32")));
 }
 
 } // end namespace

polly/test/ScopInfo/invariant_load_dereferenceable.ll

 ; CHECK-NEXT:               Execution Context: [sizeA] -> {  :  }
 ; CHECK-NEXT:       }
 
 ; CHECK:            MayWriteAccess := [Reduction Type: NONE] [Scalar: 0]
 ; CHECK-NEXT:               [sizeA] -> { Stmt_for_body_j__TO__for_latch_j[i0, i1] -> MemRef_A[i1, i0] };
 
 ; CHECK-NOT: Function: foo_undereferanceable
 
-define void @foo_dereferanceable(double* %A, double* %B, i64* dereferenceable(8) %sizeA_ptr,
+define void @foo_dereferanceable(double* %A, double* %B, i64* dereferenceable(8) align 8 %sizeA_ptr,
     i32 %lb.i, i32 %lb.j, i32 %ub.i, i32 %ub.j) {
 entry:
   br label %for.i
 
 for.i:
   %indvar.i = phi i32 [0, %entry], [%indvar.next.i, %for.latch.i]
   %indvar.next.i = add i32 %indvar.i, 1
   %cmp.i = icmp sle i32 %indvar.i, 1024