[WIP] Expose functions to determine pointer properties (Align & Deref)

[jdoerfert]

Summary

NOTE: This is a prototype to show an alternative to the two solutionssketched in http://lists.llvm.org/pipermail/llvm-dev/2019-August/134680.html .

In this patch Value::getPointerDereferenceableBytes and
Value::getPointerAlignment are extracted into more powerful versions
living alongside isDereferenceableAndAlignedPointer in
Analysis/Loads.h. The functions have also been enriched wrt. GEP
support and unified wrt. value kinds they can unpack. Thus, the only
"new" logic is concerned with GEP handling everything else is
copied/moved from other places.

NOTE: One caveat is that at least one use site (ConstantFold.cpp) does not have access to the analysis library in which the functions now live.

NOTE: Changes to downstream code should be mechanical, I used: %s/\(\w\+\)->getPointerAlignment(/getPointerAlignment(\1, /

NOTE: Not all affected tests have been updated but only one to show how the improved GEP logic affects alignment.

[jdoerfert]

Update tests and fix errors

[joerg]

At least for freestanding environments, it would be useful to separate nonnull completely from deferencable. GCC has a separate flag for it, which might also be a reasonable idea.

[jdoerfert]

In D66618#1645472, @joerg wrote:

At least for freestanding environments, it would be useful to separate nonnull completely from deferencable. GCC has a separate flag for it, which might also be a reasonable idea.

If you set the function attribute accordingly that should already work, e.g., null will be considered any other pointer.

[efriedma]

Can we remove the CanBeNull argument from getPointerDereferenceableBytes()? It looks like it's currently unused. Or are you planning to use it somewhere?

llvm/include/llvm/Analysis/Loads.h

82

Maybe describe what it means if IsKnownDeref is false, in a little more detail?

[jdoerfert]

In D66618#1645993, @efriedma wrote:

Can we remove the CanBeNull argument from getPointerDereferenceableBytes()? It looks like it's currently unused. Or are you planning to use it somewhere?

This is a good question. For now, there are no users but there is a situation where we could use it: When we derive dereferenceable in the Attributor we also derive nonnull separately, if we would return false for CanBeNull we could update the nonnull attribute directly. Maybe there are other use cases, e.g., use flow information to rule out NULL, but I fail to see where we would exploit those.

For sure I have to describe better what all the combinations of return values would mean.

[jdoerfert]

Update

[jdoerfert]

Improve comment

[jdoerfert]

@reames Would you be OK with this?

[lebedev.ri]

llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll

94 ↗

(On Diff #217574)

I think you want to first regenerate check-lines in trunk.

[lebedev.ri]

Can this diff be simplified?
There's a lot of changes there.

[lebedev.ri]

What's the status here?

[jdoerfert]

@lebedev.ri There were some concerns and I first have to reevaluate how to address them and achieve value in the move. Long story short, this is halted for now.

[lebedev.ri]

This review may be stuck/dead, consider abandoning if no longer relevant.
Removing myself as reviewer in attempt to clean dashboard.

llvm/include/llvm/Analysis/Loads.h

 /// If it is not obviously safe to load from the specified pointer, we do a
 /// quick local scan of the basic block containing ScanFrom, to determine if
 /// the address is already accessed.
 bool isSafeToLoadUnconditionally(Value *V, Type *Ty, unsigned Align,
                                  const DataLayout &DL,
                                  Instruction *ScanFrom = nullptr,
                                  const DominatorTree *DT = nullptr);
 
+/// Returns the number of bytes known to be dereferenceable for the
+/// pointer value \p V.
+///
+/// If \p CanBeNull is set by this function the pointer can either be null or be
+/// dereferenceable up to the returned number of bytes (or both).
+uint64_t getPointerDereferenceableBytes(const Value *V, const DataLayout &DL,
+                                        bool &CanBeNull);
+
+/// Returns an alignment of the pointer value \p V.
+///
+/// Returns an alignment which is either specified explicitly, e.g. via
+/// align attribute of a function argument, or guaranteed by DataLayout.
+unsigned getPointerAlignment(const Value *V, const DataLayout &DL);
+
 /// The default number of maximum instructions to scan in the block, used by
 /// FindAvailableLoadedValue().
 extern cl::opt<unsigned> DefMaxInstsToScan;
 
 /// Scan backwards to see if we have the value of the given load available
 /// locally within a small number of instructions.
 ///
 /// You can use this function to scan across multiple blocks: after you call

llvm/include/llvm/IR/Value.h

#include "llvm/IR/Value.def"
   /// Returns the original pointer value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripInBoundsOffsets() const;
   Value *stripInBoundsOffsets() {
     return const_cast<Value *>(
                       static_cast<const Value *>(this)->stripInBoundsOffsets());
   }
 
-  /// Returns the number of bytes known to be dereferenceable for the
-  /// pointer value.
-  ///
-  /// If CanBeNull is set by this function the pointer can either be null or be
-  /// 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.
-  unsigned 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,
                                 const BasicBlock *PredBB) const;

llvm/lib/Analysis/CaptureTracking.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/ADT/SmallSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/CFG.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/OrderedBasicBlock.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/Dominators.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 
 using namespace llvm;
bool CaptureTracker::isDereferenceableOrNull(Value *O, const DataLayout &DL) {
   // would make the pointer point outside of the allocated object
   // and thus make the GEP result a poison value. Similarly, other
   // dereferenceable pointers cannot be manipulated without producing
   // poison.
   if (auto *GEP = dyn_cast<GetElementPtrInst>(O))
     if (GEP->isInBounds())
       return true;
   bool CanBeNull;
-  return O->getPointerDereferenceableBytes(DL, CanBeNull);
+  return getPointerDereferenceableBytes(O, DL, CanBeNull);
 }
 
 namespace {
   struct SimpleCaptureTracker : public CaptureTracker {
     explicit SimpleCaptureTracker(bool ReturnCaptures)
       : ReturnCaptures(ReturnCaptures), Captured(false) {}
 
     void tooManyUses() override { Captured = true; }

llvm/lib/Analysis/Loads.cpp

 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #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"
 
+#include <limits.h>
+
 using namespace llvm;
 
 static bool isAligned(const Value *Base, const APInt &Offset, unsigned Align,
                       const DataLayout &DL) {
-  APInt BaseAlign(Offset.getBitWidth(), Base->getPointerAlignment(DL));
+  APInt BaseAlign(Offset.getBitWidth(), getPointerAlignment(Base, DL));
 
   if (!BaseAlign) {
     Type *Ty = Base->getType()->getPointerElementType();
     if (!Ty->isSized())
       return false;
     BaseAlign = DL.getABITypeAlignment(Ty);
   }
 
   APInt Alignment(Offset.getBitWidth(), Align);
 
   assert(Alignment.isPowerOf2() && "must be a power of 2!");
   return BaseAlign.uge(Alignment) && !(Offset & (Alignment-1));
 }
 
 static bool isAligned(const Value *Base, unsigned Align, const DataLayout &DL) {
   Type *Ty = Base->getType();
   assert(Ty->isSized() && "must be sized");
   APInt Offset(DL.getTypeStoreSizeInBits(Ty), 0);
   return isAligned(Base, Offset, Align, DL);
 }
 
-/// 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, unsigned Align, const APInt &Size, const DataLayout &DL,
-    const Instruction *CtxI, const DominatorTree *DT,
+static unsigned getPointerAlignment(const Value *V, const DataLayout &DL,
                                     SmallPtrSetImpl<const Value *> &Visited) {
-  // Already visited?  Bail out, we've likely hit unreachable code.
-  if (!Visited.insert(V).second)
-    return false;
+  assert(V->getType()->isPointerTy() && "must be pointer");
 
-  // Note that it is not safe to speculate into a malloc'd region because
-  // malloc may return null.
-
-  // bitcast instructions are no-ops as far as dereferenceability is concerned.
-  if (const BitCastOperator *BC = dyn_cast<BitCastOperator>(V))
-    return isDereferenceableAndAlignedPointer(BC->getOperand(0), Align, Size,
-                                              DL, CtxI, DT, Visited);
+  static const unsigned MAX_ALIGN = 1U << 29;
+  if (!Visited.insert(V).second)
+    return MAX_ALIGN;
 
-  bool CheckForNonNull = false;
-  APInt KnownDerefBytes(Size.getBitWidth(),
-                        V->getPointerDereferenceableBytes(DL, CheckForNonNull));
-  if (KnownDerefBytes.getBoolValue()) {
-    if (KnownDerefBytes.uge(Size))
-      if (!CheckForNonNull || isKnownNonZero(V, DL, 0, nullptr, CtxI, DT))
-        return isAligned(V, Align, DL);
+  unsigned Align = 0;
+  if (auto *GO = dyn_cast<GlobalObject>(V)) {
+    if (isa<Function>(GO)) {
+      MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign();
+      unsigned Align = FunctionPtrAlign ? FunctionPtrAlign->value() : 0;
+      switch (DL.getFunctionPtrAlignType()) {
+      case DataLayout::FunctionPtrAlignType::Independent:
+        return Align;
+      case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
+        return std::max(Align, GO->getAlignment());
+      }
+    }
+    Align = GO->getAlignment();
+    if (Align == 0) {
+      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())
+            Align = DL.getPreferredAlignment(GVar);
+          else
+            Align = DL.getABITypeAlignment(ObjectType);
         }
-
-  // For GEPs, determine if the indexing lands within the allocated object.
-  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
+      }
+    }
+  } else if (auto *A = dyn_cast<Argument>(V)) {
+    Align = A->getParamAlignment();
+
+    if (!Align && 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())
+        Align = DL.getABITypeAlignment(EltTy);
+    }
+  } else if (auto *AI = dyn_cast<AllocaInst>(V)) {
+    Align = AI->getAlignment();
+    if (Align == 0) {
+      Type *AllocatedType = AI->getAllocatedType();
+      if (AllocatedType->isSized())
+        Align = DL.getPrefTypeAlignment(AllocatedType);
+    }
+  } else if (auto *Call = dyn_cast<CallBase>(V)) {
+    Align = Call->getRetAlignment();
+    if (Align == 0 && Call->getCalledFunction())
+      Align = Call->getCalledFunction()->getAttributes().getRetAlignment();
+    if (Align == 0)
+      if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
+        Align = getPointerAlignment(RP, DL, Visited);
+  } else if (auto *LI = dyn_cast<LoadInst>(V)) {
+    if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
+      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+      Align = CI->getLimitedValue();
+    }
+  } else if (auto *RI = dyn_cast<GCRelocateInst>(V)) {
+    // For gc.relocate, look through relocations
+    Align = getPointerAlignment(RI->getDerivedPtr(), DL, Visited);
+  } else if (auto *ASC = dyn_cast<AddrSpaceCastInst>(V)) {
+    Align = getPointerAlignment(ASC->getPointerOperand(), DL, Visited);
+  } else if (auto *GEP = dyn_cast<GEPOperator>(V)) {
     const Value *Base = GEP->getPointerOperand();
 
     APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
-    if (!GEP->accumulateConstantOffset(DL, Offset) || Offset.isNegative() ||
-        !Offset.urem(APInt(Offset.getBitWidth(), Align)).isMinValue())
-      return false;
+    if (GEP->accumulateConstantOffset(DL, Offset) && Offset != 0) {
+      auto BaseAlign = getPointerAlignment(Base, DL, Visited);
+      if (BaseAlign > 1) {
+        // For the purpose of alignment computation we treat negative offsets as
+        // if they were positive, so we only discuss positive offsets below.
+        // We assume k_x values are existentially quantified.
+        //
+        // Base has alignment BA, thus:
+        //   Base = k_0 * BA
+        // GEP equals Base + Offset, thus:
+        //   GEP = k_0 * BA + Offset
+        // With GCD = gcd(BA, Offset), BA = k_1 * GCD, and Offset = k_2 * GCD we
+        // can express GEP as follows:
+        //   GEP = k_0 * (k_1 * GCD) + k_2 * GCD
+        // The common factor in both terms is GCD, so we can express it as:
+        //   GEP = GCD * (k_0 * k_1 + k_2)
+        // Which implies that the GEP has GCD alignment.
+        APInt GCD = APIntOps::GreatestCommonDivisor(
+            Offset.abs(), APInt(Offset.getBitWidth(), BaseAlign));
+        Align = GCD.getZExtValue();
+      }
+    }
+  }
 
-    // If the base pointer is dereferenceable for Offset+Size bytes, then the
-    // GEP (== Base + Offset) is dereferenceable for Size bytes.  If the base
-    // pointer is aligned to Align bytes, and the Offset is divisible by Align
-    // then the GEP (== Base + Offset == k_0 * Align + k_1 * Align) is also
-    // aligned to Align bytes.
-
-    // Offset and Size may have different bit widths if we have visited an
-    // addrspacecast, so we can't do arithmetic directly on the APInt values.
-    return isDereferenceableAndAlignedPointer(
-        Base, Align, Offset + Size.sextOrTrunc(Offset.getBitWidth()),
-        DL, CtxI, DT, Visited);
-  }
+  return Align;
 
-  // For gc.relocate, look through relocations
-  if (const GCRelocateInst *RelocateInst = dyn_cast<GCRelocateInst>(V))
-    return isDereferenceableAndAlignedPointer(
-        RelocateInst->getDerivedPtr(), Align, Size, DL, CtxI, DT, Visited);
-
-  if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V))
-    return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align, Size,
-                                              DL, CtxI, DT, Visited);
+unsigned llvm::getPointerAlignment(const Value *V, const DataLayout &DL) {
+  SmallPtrSet<const Value *, 4> Visited;
+  return ::getPointerAlignment(V, DL, Visited);
+}
+
+static uint64_t
+getPointerDereferenceableBytes(const Value *V, const DataLayout &DL,
+                               bool &CanBeNull,
+                               SmallPtrSetImpl<const Value *> &Visited) {
+  assert(V->getType()->isPointerTy() && "must be pointer");
+  if (!Visited.insert(V).second)
+    return std::numeric_limits<uint64_t>::max();
 
-  if (const auto *Call = dyn_cast<CallBase>(V))
+  const Value *Stripped = V->stripPointerCastsSameRepresentation();
+  if (Stripped != V)
+    return getPointerDereferenceableBytes(Stripped, DL, CanBeNull, Visited);
+
+  const Function *F = nullptr;
+  uint64_t DerefBytes = 0;
+  CanBeNull = false;
+  if (const Argument *A = dyn_cast<Argument>(V)) {
+    F = A->getParent();
+    DerefBytes = A->getDereferenceableBytes();
+    if (DerefBytes == 0 && (A->hasByValAttr() || A->hasStructRetAttr())) {
+      Type *PT = cast<PointerType>(A->getType())->getElementType();
+      if (PT->isSized())
+        DerefBytes = DL.getTypeStoreSize(PT);
+    }
+    if (DerefBytes == 0) {
+      DerefBytes = A->getDereferenceableOrNullBytes();
+      CanBeNull = true;
+    }
+  } else if (const auto *Call = dyn_cast<CallBase>(V)) {
+    DerefBytes = Call->getDereferenceableBytes(AttributeList::ReturnIndex);
+    if (DerefBytes == 0) {
+      DerefBytes =
+          Call->getDereferenceableOrNullBytes(AttributeList::ReturnIndex);
+      CanBeNull = true;
+    }
+    if (DerefBytes == 0)
       if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
-      return isDereferenceableAndAlignedPointer(RP, Align, Size, DL, CtxI, DT,
-                                                Visited);
+        return getPointerDereferenceableBytes(RP, DL, CanBeNull, Visited);
+  } else if (const LoadInst *LI = dyn_cast<LoadInst>(V)) {
+    if (MDNode *MD = LI->getMetadata(LLVMContext::MD_dereferenceable)) {
+      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+      DerefBytes = CI->getLimitedValue();
+    }
+    if (DerefBytes == 0) {
+      if (MDNode *MD =
+              LI->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
+        ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+        DerefBytes = CI->getLimitedValue();
+      }
+      CanBeNull = true;
+    }
+  } else if (auto *IP = dyn_cast<IntToPtrInst>(V)) {
+    if (MDNode *MD = IP->getMetadata(LLVMContext::MD_dereferenceable)) {
+      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+      DerefBytes = CI->getLimitedValue();
+    }
+    if (DerefBytes == 0) {
+      if (MDNode *MD =
+              IP->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
+        ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
+        DerefBytes = CI->getLimitedValue();
+      }
+      CanBeNull = true;
+    }
+  } else if (auto *AI = dyn_cast<AllocaInst>(V)) {
+    if (!AI->isArrayAllocation()) {
+      DerefBytes = DL.getTypeStoreSize(AI->getAllocatedType());
+      CanBeNull = false;
+    }
+  } else if (auto *GV = dyn_cast<GlobalVariable>(V)) {
+    if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
+      // TODO: Don't outright reject hasExternalWeakLinkage but set the
+      // CanBeNull flag.
+      DerefBytes = DL.getTypeStoreSize(GV->getValueType());
+      CanBeNull = false;
+    }
+  } else if (auto *RI = dyn_cast<GCRelocateInst>(V)) {
+    // For gc.relocate, look through relocations
+    return getPointerDereferenceableBytes(RI->getDerivedPtr(), DL, CanBeNull,
+  } else if (auto *ASC = dyn_cast<AddrSpaceCastInst>(V)) {
+    DerefBytes = getPointerDereferenceableBytes(ASC->getPointerOperand(), DL,
+                                                CanBeNull, Visited);
+  } else if (auto *GEP = dyn_cast<GEPOperator>(V)) {
+    APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
+    // Give up on non-constant GEPs.
+    if (!GEP->accumulateConstantOffset(DL, Offset))
+      return 0;
+
+    // If Base has N dereferenceable bytes and is O (=Offset) away from the
+    // GEP, then:
+    //  - if 0 is null, we take the base result.
+    //  - if O is positive, the GEP has max(0, N - O) dereferenceable bytes
+    //                      because it is O bytes advanced from the base.
+    //  - if O is negative and inbounds, the GEP has N + abs(O) dereferenceable
+    //                                   bytes because inbounds need to stay in
+    //                                   the same allocation.
+    //  - if O is negative and not inbounds, the GEP has 0 dereferenceable bytes
+    //                                       because we do not know if we are
+    //                                       still in the allocation or not.
+    //
+    // The "can be null" is set to false if we have an offset that is not null
+    // and an inbounds GEP. Note that this is later overwritten if null pointers
+    // are defined.
+    const Value *Base = GEP->getPointerOperand();
+    uint64_t BaseDerefBytes =
+        getPointerDereferenceableBytes(Base, DL, CanBeNull, Visited);
+    if (Offset == 0) {
+      DerefBytes = BaseDerefBytes;
+    } else if (Offset.getSExtValue() > 0) {
+      DerefBytes =
+          std::max(int64_t(BaseDerefBytes - Offset.getZExtValue()), int64_t(0));
+      CanBeNull = !GEP->isInBounds();
+    } else {
+      assert(Offset.getSExtValue() < 0 && "Did not expect zero offset!");
+      if (GEP->isInBounds())
+        DerefBytes = BaseDerefBytes + Offset.abs().getZExtValue();
+      else
+        DerefBytes = 0;
+      CanBeNull = !GEP->isInBounds();
+    }
+  }
 
-  // If we don't know, assume the worst.
-  return false;
+  if (auto *I = dyn_cast<Instruction>(V))
+    F = I->getFunction();
+
+  CanBeNull |= NullPointerIsDefined(F, V->getType()->getPointerAddressSpace());
+  return DerefBytes;
+}
+
+uint64_t llvm::getPointerDereferenceableBytes(const Value *V,
+                                              const DataLayout &DL,
+                                              bool &CanBeNull) {
+  SmallPtrSet<const Value *, 4> Visited;
+  return ::getPointerDereferenceableBytes(V, DL,CanBeNull, Visited);
 }
 
 bool llvm::isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
                                               const APInt &Size,
                                               const DataLayout &DL,
                                               const Instruction *CtxI,
                                               const DominatorTree *DT) {
-  SmallPtrSet<const Value *, 32> Visited;
-  return ::isDereferenceableAndAlignedPointer(V, Align, Size, DL, CtxI, DT,
-                                              Visited);
+  bool CheckForNonNull = false;
+  APInt KnownDerefBytes(Size.getBitWidth(),
+                        getPointerDereferenceableBytes(V, DL, CheckForNonNull));
+  if (KnownDerefBytes.getBoolValue())
+    if (KnownDerefBytes.uge(Size))
+      if (!CheckForNonNull || isKnownNonZero(V, DL, 0, nullptr, CtxI, DT))
+        return ::isAligned(V, Align, DL);
+
+  // If we don't know, assume the worst.
+  return false;
 }
 
 bool llvm::isDereferenceableAndAlignedPointer(const Value *V, Type *Ty,
                                               unsigned Align,
                                               const DataLayout &DL,
                                               const Instruction *CtxI,
                                               const DominatorTree *DT) {
   // When dereferenceability information is provided by a dereferenceable
   // attribute, we know exactly how many bytes are dereferenceable. If we can
   // determine the exact offset to the attributed variable, we can use that
   // information here.
 
   // Require ABI alignment for loads without alignment specification
   if (Align == 0)
     Align = DL.getABITypeAlignment(Ty);
 
   if (!Ty->isSized())
     return false;
 
-  SmallPtrSet<const Value *, 32> Visited;
   return ::isDereferenceableAndAlignedPointer(
       V, Align,
       APInt(DL.getIndexTypeSizeInBits(V->getType()), DL.getTypeStoreSize(Ty)),
-      DL, CtxI, DT, Visited);
+      DL, CtxI, DT);
 }
 
 bool llvm::isDereferenceablePointer(const Value *V, Type *Ty,
                                     const DataLayout &DL,
                                     const Instruction *CtxI,
                                     const DominatorTree *DT) {
   return isDereferenceableAndAlignedPointer(V, Ty, 1, DL, CtxI, DT);
 }

llvm/lib/Analysis/ValueTracking.cpp

if (const GlobalAlias *GA = dyn_cast<GlobalAlias>(V)) {
     return;
   }
 
   if (const Operator *I = dyn_cast<Operator>(V))
     computeKnownBitsFromOperator(I, Known, Depth, Q);
 
   // Aligned pointers have trailing zeros - refine Known.Zero set
   if (V->getType()->isPointerTy()) {
-    unsigned Align = V->getPointerAlignment(Q.DL);
+    unsigned Align = getPointerAlignment(V, Q.DL);
     if (Align)
       Known.Zero.setLowBits(countTrailingZeros(Align));
   }
 
   // computeKnownBitsFromAssume strictly refines Known.
   // Therefore, we run them after computeKnownBitsFromOperator.
 
   // Check whether a nearby assume intrinsic can determine some known bits.

llvm/lib/CodeGen/CodeGenPrepare.cpp

 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/BlockFrequencyInfo.h"
 #include "llvm/Analysis/BranchProbabilityInfo.h"
 #include "llvm/Analysis/ConstantFolding.h"
 #include "llvm/Analysis/InstructionSimplify.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/ProfileSummaryInfo.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Transforms/Utils/Local.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/VectorUtils.h"
for (auto &Arg : CI->arg_operands()) {
           DL->getTypeAllocSize(AI->getAllocatedType()) >= MinSize + Offset2)
         AI->setAlignment(PrefAlign);
       // Global variables can only be aligned if they are defined in this
       // object (i.e. they are uniquely initialized in this object), and
       // over-aligning global variables that have an explicit section is
       // forbidden.
       GlobalVariable *GV;
       if ((GV = dyn_cast<GlobalVariable>(Val)) && GV->canIncreaseAlignment() &&
-          GV->getPointerAlignment(*DL) < PrefAlign &&
+          getPointerAlignment(GV, *DL) < PrefAlign &&
           DL->getTypeAllocSize(GV->getValueType()) >=
               MinSize + Offset2)
         GV->setAlignment(PrefAlign);
     }
     // If this is a memcpy (or similar) then we may be able to improve the
     // alignment
     if (MemIntrinsic *MI = dyn_cast<MemIntrinsic>(CI)) {
       unsigned DestAlign = getKnownAlignment(MI->getDest(), *DL);
bool CodeGenPrepare::optimizeCallInst(CallInst *CI, bool &ModifiedDT) {
 
   IntrinsicInst *II = dyn_cast<IntrinsicInst>(CI);
   if (II) {
     switch (II->getIntrinsicID()) {
     default: break;
     case Intrinsic::experimental_widenable_condition: {
       // Give up on future widening oppurtunties so that we can fold away dead
       // paths and merge blocks before going into block-local instruction
-      // selection.   
+      // selection.
       if (II->use_empty()) {
         II->eraseFromParent();
         return true;
       }
       Constant *RetVal = ConstantInt::getTrue(II->getContext());
       resetIteratorIfInvalidatedWhileCalling(BB, [&]() {
         replaceAndRecursivelySimplify(CI, RetVal, TLInfo, nullptr);
       });

llvm/lib/IR/ConstantFold.cpp

 // pieces that don't need DataLayout, and the pieces that do. This is to avoid
 // a dependence in IR on Target.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ConstantFold.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
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));
 
           unsigned GVAlign;
 
-          if (Module *TheModule = GV->getParent()) {
-            GVAlign = GV->getPointerAlignment(TheModule->getDataLayout());
+          if (GV->getParent()) {
+            // Deduction of alignment is done via getPointerAlignment but that
+            // function is not accessible from the IR library so we do only look
+            // at the annotated alignment. Alternatively we can copy the logic
+            // for global objects here.
+            GVAlign = GV->getAlignment();
 
             // 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)

llvm/lib/IR/Value.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Value.h"
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DerivedUser.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
Value::stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
 
   return V;
 }
 
 const Value *Value::stripInBoundsOffsets() const {
   return stripPointerCastsAndOffsets<PSK_InBounds>(this);
 }
 
-uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
-                                               bool &CanBeNull) const {
-  assert(getType()->isPointerTy() && "must be pointer");
-
-  auto AS = getType()->getPointerAddressSpace();
-  bool NullIsValid = (AS != 0);
-  if (auto *I = dyn_cast<Instruction>(this))
-    NullIsValid = NullPointerIsDefined(I->getFunction(), AS);
-
-  uint64_t DerefBytes = 0;
-  CanBeNull = false;
-  if (const Argument *A = dyn_cast<Argument>(this)) {
-    NullIsValid = NullPointerIsDefined(A->getParent(), AS);
-    DerefBytes = A->getDereferenceableBytes();
-    if (DerefBytes == 0 && (A->hasByValAttr() || A->hasStructRetAttr())) {
-      Type *PT = cast<PointerType>(A->getType())->getElementType();
-      if (PT->isSized())
-        DerefBytes = DL.getTypeStoreSize(PT);
-    }
-    if (DerefBytes == 0) {
-      DerefBytes = A->getDereferenceableOrNullBytes();
-      CanBeNull = true;
-    }
-  } else if (const auto *Call = dyn_cast<CallBase>(this)) {
-    DerefBytes = Call->getDereferenceableBytes(AttributeList::ReturnIndex);
-    if (DerefBytes == 0) {
-      DerefBytes =
-          Call->getDereferenceableOrNullBytes(AttributeList::ReturnIndex);
-      CanBeNull = true;
-    }
-  } else if (const LoadInst *LI = dyn_cast<LoadInst>(this)) {
-    if (MDNode *MD = LI->getMetadata(LLVMContext::MD_dereferenceable)) {
-      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
-      DerefBytes = CI->getLimitedValue();
-    }
-    if (DerefBytes == 0) {
-      if (MDNode *MD =
-              LI->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
-        ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
-        DerefBytes = CI->getLimitedValue();
-      }
-      CanBeNull = true;
-    }
-  } else if (auto *IP = dyn_cast<IntToPtrInst>(this)) {
-    if (MDNode *MD = IP->getMetadata(LLVMContext::MD_dereferenceable)) {
-      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
-      DerefBytes = CI->getLimitedValue();
-    }
-    if (DerefBytes == 0) {
-      if (MDNode *MD =
-              IP->getMetadata(LLVMContext::MD_dereferenceable_or_null)) {
-        ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
-        DerefBytes = CI->getLimitedValue();
-      }
-      CanBeNull = true;
-    }
-  } else if (auto *AI = dyn_cast<AllocaInst>(this)) {
-    if (!AI->isArrayAllocation()) {
-      DerefBytes = DL.getTypeStoreSize(AI->getAllocatedType());
-      CanBeNull = false;
-    }
-  } else if (auto *GV = dyn_cast<GlobalVariable>(this)) {
-    if (GV->getValueType()->isSized() && !GV->hasExternalWeakLinkage()) {
-      // TODO: Don't outright reject hasExternalWeakLinkage but set the
-      // CanBeNull flag.
-      DerefBytes = DL.getTypeStoreSize(GV->getValueType());
-      CanBeNull = false;
-    }
-  }
-
-  CanBeNull = !NullIsValid;
-  return DerefBytes;
-}
-
-unsigned Value::getPointerAlignment(const DataLayout &DL) const {
-  assert(getType()->isPointerTy() && "must be pointer");
-
-  unsigned Align = 0;
-  if (auto *GO = dyn_cast<GlobalObject>(this)) {
-    if (isa<Function>(GO)) {
-      MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign();
-      unsigned Align = FunctionPtrAlign ? FunctionPtrAlign->value() : 0;
-      switch (DL.getFunctionPtrAlignType()) {
-      case DataLayout::FunctionPtrAlignType::Independent:
-        return Align;
-      case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
-        return std::max(Align, GO->getAlignment());
-      }
-    }
-    Align = GO->getAlignment();
-    if (Align == 0) {
-      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())
-            Align = DL.getPreferredAlignment(GVar);
-          else
-            Align = DL.getABITypeAlignment(ObjectType);
-        }
-      }
-    }
-  } else if (const Argument *A = dyn_cast<Argument>(this)) {
-    Align = A->getParamAlignment();
-
-    if (!Align && 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())
-        Align = DL.getABITypeAlignment(EltTy);
-    }
-  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(this)) {
-    Align = AI->getAlignment();
-    if (Align == 0) {
-      Type *AllocatedType = AI->getAllocatedType();
-      if (AllocatedType->isSized())
-        Align = DL.getPrefTypeAlignment(AllocatedType);
-    }
-  } else if (const auto *Call = dyn_cast<CallBase>(this)) {
-    Align = Call->getRetAlignment();
-    if (Align == 0 && Call->getCalledFunction())
-      Align = Call->getCalledFunction()->getAttributes().getRetAlignment();
-  } 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));
-      Align = CI->getLimitedValue();
-    }
-
-  return Align;
-}
-
 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();
-    unsigned Align = G->getGlobal()->getPointerAlignment(DL);
+    unsigned Align = getPointerAlignment(G->getGlobal(), DL);
     return Align >= 4 && G->getOffset() % 4 == 0;
   }
   if (auto *C = dyn_cast<ConstantPoolSDNode>(N))
     return C->getAlignment() >= 4 && C->getOffset() % 4 == 0;
   return false;
 }]>;
 
 def LDRWl : LoadLiteral<0b00, 0, GPR32z, "ldr",

llvm/lib/Transforms/IPO/Attributor.cpp

auto VisitValueCB = [&](Value &V, DerefState &T, bool Stripped) -> bool {
 
       const auto &AA =
           A.getAAFor<AADereferenceable>(*this, IRPosition::value(*Base));
       int64_t DerefBytes = 0;
       if (!Stripped && this == &AA) {
         // Use IR information if we did not strip anything.
         // TODO: track globally.
         bool CanBeNull;
-        DerefBytes = Base->getPointerDereferenceableBytes(DL, CanBeNull);
+        DerefBytes = getPointerDereferenceableBytes(Base, DL, CanBeNull);
         T.GlobalState.indicatePessimisticFixpoint();
       } else {
         const DerefState &DS = static_cast<const DerefState &>(AA.getState());
         DerefBytes = DS.DerefBytesState.getAssumed();
         T.GlobalState &= DS.GlobalState;
       }
 
       T.takeAssumedDerefBytesMinimum(
struct AAAlignFloating : AAAlignImpl {
   ChangeStatus updateImpl(Attributor &A) override {
     const DataLayout &DL = A.getDataLayout();
 
     auto VisitValueCB = [&](Value &V, 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.
-        T.takeKnownMaximum(V.getPointerAlignment(DL));
+        T.takeKnownMaximum(getPointerAlignment(&V, DL));
         T.indicatePessimisticFixpoint();
       } else {
         // Use abstract attribute information.
         const AAAlign::StateType &DS =
             static_cast<const AAAlign::StateType &>(AA.getState());
         T ^= DS;
       }
       return T.isValidState();

llvm/test/Transforms/InstCombine/constant-fold-gep.ll

 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 0), align 16
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 0), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 1), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 1), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 2), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 2), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 1, i64 0), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 3), align 4
-; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 1, i64 1), align 4
+; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 1, i64 1), align 16
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 4), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 1, i64 2), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 5), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 0, i64 0), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 6), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 0, i64 1), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 7), align 4
-; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 0, i64 2), align 8
+; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 0, i64 2), align 16
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 8), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 1, i64 0), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 9), align 4
-; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 1, i64 1), align 4
+; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 1, i64 1), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 10), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 1, i32 1, i64 2), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 11), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 0, i64 0), align 16
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 12), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 0, i64 1), align 4
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 13), align 4
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 0, i64 2), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 14), align 8
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 1, i64 0), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 15), align 8
-; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 1, i64 1), align 8
+; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 1, i64 1), align 16
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 16), align 8
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 2, i32 1, i64 2), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 17), align 8
 ; CHECK: store i32 1, i32* getelementptr inbounds ([3 x %struct.X], [3 x %struct.X]* @Y, i64 1, i64 0, i32 0, i64 0), align 8
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 18), align 8
 ; CHECK: store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 2, i64 0, i32 0, i64 0), align 16
   store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 0, i64 0, i32 0, i64 36), align 8
 ; CHECK: store i32 1, i32* getelementptr ([3 x %struct.X], [3 x %struct.X]* @Y, i64 1, i64 0, i32 0, i64 1), align 8

llvm/unittests/IR/FunctionTest.cpp

 //===- FunctionTest.cpp - Function unit tests -----------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Analysis/Loads.h"
 #include "gtest/gtest.h"
 using namespace llvm;
 
 namespace {
 
 TEST(FunctionTest, hasLazyArguments) {
   LLVMContext C;
 

 }
 
 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(0U, Func->getPointerAlignment(DataLayout("")));
-  EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fi8")));
-  EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fn8")));
-  EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fi16")));
-  EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fn16")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fi32")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn32")));
+  EXPECT_EQ(0U, getPointerAlignment(Func, DataLayout("")));
+  EXPECT_EQ(1U, getPointerAlignment(Func, DataLayout("Fi8")));
+  EXPECT_EQ(1U, getPointerAlignment(Func, DataLayout("Fn8")));
+  EXPECT_EQ(2U, getPointerAlignment(Func, DataLayout("Fi16")));
+  EXPECT_EQ(2U, getPointerAlignment(Func, DataLayout("Fn16")));
+  EXPECT_EQ(4U, getPointerAlignment(Func, DataLayout("Fi32")));
+  EXPECT_EQ(4U, getPointerAlignment(Func, DataLayout("Fn32")));
 
   Func->setAlignment(4U);
 
-  EXPECT_EQ(0U, Func->getPointerAlignment(DataLayout("")));
-  EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fi8")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn8")));
-  EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fi16")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn16")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fi32")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn32")));
+  EXPECT_EQ(0U, getPointerAlignment(Func, DataLayout("")));
+  EXPECT_EQ(1U, getPointerAlignment(Func, DataLayout("Fi8")));
+  EXPECT_EQ(4U, getPointerAlignment(Func, DataLayout("Fn8")));
+  EXPECT_EQ(2U, getPointerAlignment(Func, DataLayout("Fi16")));
+  EXPECT_EQ(4U, getPointerAlignment(Func, DataLayout("Fn16")));
+  EXPECT_EQ(4U, getPointerAlignment(Func, DataLayout("Fi32")));
+  EXPECT_EQ(4U, getPointerAlignment(Func, DataLayout("Fn32")));
 }
 
 } // end namespace