diff --git a/llvm/include/llvm/Analysis/Loads.h b/llvm/include/llvm/Analysis/Loads.h
--- a/llvm/include/llvm/Analysis/Loads.h
+++ b/llvm/include/llvm/Analysis/Loads.h
@@ -74,6 +74,24 @@
                                  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 be null.
+/// If \p IsKnownDeref is set by this function the pointer is known to be
+/// dereferenceable up to the returned number of bytes.
+///
+/// Note that both \p CanBeNull and \p IsKnownDeref can be set if null is a
+/// valid pointer.
+uint64_t getPointerDereferenceableBytes(const Value *V, const DataLayout &DL,
+                                        bool &CanBeNull, bool &IsKnownDeref);
+
+/// 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;
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
@@ -620,20 +620,6 @@
                       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
diff --git a/llvm/lib/Analysis/CaptureTracking.cpp b/llvm/lib/Analysis/CaptureTracking.cpp
--- a/llvm/lib/Analysis/CaptureTracking.cpp
+++ b/llvm/lib/Analysis/CaptureTracking.cpp
@@ -20,6 +20,7 @@
 #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"
@@ -45,8 +46,8 @@
   if (auto *GEP = dyn_cast<GetElementPtrInst>(O))
     if (GEP->isInBounds())
       return true;
-  bool CanBeNull;
-  return O->getPointerDereferenceableBytes(DL, CanBeNull);
+  bool CanBeNull, IsKnownDeref;
+  return getPointerDereferenceableBytes(O, DL, CanBeNull, IsKnownDeref);
 }
 
 namespace {
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
@@ -22,21 +22,15 @@
 #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));
-
-  if (!BaseAlign) {
-    Type *Ty = Base->getType()->getPointerElementType();
-    if (!Ty->isSized())
-      return false;
-    BaseAlign = DL.getABITypeAlignment(Ty);
-  }
-
+  APInt BaseAlign(Offset.getBitWidth(),
+                  std::max(1U, getPointerAlignment(Base, DL)));
   APInt Alignment(Offset.getBitWidth(), Align);
-
   assert(Alignment.isPowerOf2() && "must be a power of 2!");
   return BaseAlign.uge(Alignment) && !(Offset & (Alignment-1));
 }
@@ -48,71 +42,268 @@
   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,
-    SmallPtrSetImpl<const Value *> &Visited) {
-  // Already visited?  Bail out, we've likely hit unreachable code.
+static unsigned getPointerAlignment(const Value *V, const DataLayout &DL,
+                                    SmallPtrSetImpl<const Value *> &Visited) {
+  assert(V->getType()->isPointerTy() && "must be pointer");
+
+  static const unsigned MAX_ALIGN = 1U << 29;
+  // The visited set catches recursion for "invalid" SSA instructions and allows
+  // recursion on PHI nodes (not yet done).
   if (!Visited.insert(V).second)
-    return false;
+    return MAX_ALIGN;
+
+  const Value *Stripped = V->stripPointerCastsSameRepresentation();
+  if (Stripped != V)
+    return getPointerAlignment(Stripped, DL, Visited);
+
+  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);
+        }
+      }
+    }
+  } else if (auto *A = dyn_cast<Argument>(V)) {
+    Align = A->getParamAlignment();
+  } 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 *RI = dyn_cast<GCRelocateInst>(V)) {
+    // For gc.relocate, look through relocations
+    Align = getPointerAlignment(RI->getDerivedPtr(), DL, Visited);
+  } 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 *ASC = dyn_cast<AddrSpaceCastInst>(V)) {
+    Align = getPointerAlignment(ASC->getPointerOperand(), DL, Visited);
+  } else if (auto *GEP = dyn_cast<GEPOperator>(V)) {
+    const Value *Base = GEP->getPointerOperand();
 
-  // Note that it is not safe to speculate into a malloc'd region because
-  // malloc may return null.
+    APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
+    if (GEP->accumulateConstantOffset(DL, Offset) && Offset != 0) {
+      auto BaseAlign = getPointerAlignment(Base, DL, Visited);
+      if (BaseAlign <= 1) {
+        // Propagate a base alignment of 1 and give up on a zero alignment.
+        Align = BaseAlign;
+      } else {
+        // 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();
 
-  // 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);
+      }
+    }
+    // Do not use type information below to improve the alignment.
+    return 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);
+  if (!Align) {
+    Type *Ty = V->getType()->getPointerElementType();
+    if (Ty->isSized())
+      Align = DL.getABITypeAlignment(Ty);
   }
 
-  // For GEPs, determine if the indexing lands within the allocated object.
-  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
-    const Value *Base = GEP->getPointerOperand();
+  return Align;
+}
 
-    APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
-    if (!GEP->accumulateConstantOffset(DL, Offset) || Offset.isNegative() ||
-        !Offset.urem(APInt(Offset.getBitWidth(), Align)).isMinValue())
-      return false;
+unsigned llvm::getPointerAlignment(const Value *V, const DataLayout &DL) {
+  SmallPtrSet<const Value *, 4> Visited;
+  return ::getPointerAlignment(V, DL, Visited);
+}
 
-    // 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);
-  }
+static uint64_t
+getPointerDereferenceableBytes(const Value *V, const DataLayout &DL,
+                               bool &CanBeNull, bool &IsKnownDeref,
+                               SmallPtrSetImpl<const Value *> &Visited) {
+  assert(V->getType()->isPointerTy() && "must be pointer");
+  CanBeNull = false;
+  IsKnownDeref = true;
 
-  // For gc.relocate, look through relocations
-  if (const GCRelocateInst *RelocateInst = dyn_cast<GCRelocateInst>(V))
-    return isDereferenceableAndAlignedPointer(
-        RelocateInst->getDerivedPtr(), Align, Size, DL, CtxI, DT, Visited);
+  // The visited set catches recursion for "invalid" SSA instructions and allows
+  // recursion on PHI nodes (not yet done).
+  if (!Visited.insert(V).second)
+    return std::numeric_limits<uint64_t>::max();
+
+  const Value *Stripped = V->stripPointerCastsSameRepresentation();
+  if (Stripped != V)
+    return getPointerDereferenceableBytes(Stripped, DL, CanBeNull, IsKnownDeref,
+                                          Visited);
+
+  const Function *F = nullptr;
+  uint64_t DerefBytes = 0;
+  CanBeNull = false;
+  if (auto *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 (auto *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, must be checkd before CallBase.
+    return getPointerDereferenceableBytes(RI->getDerivedPtr(), DL, CanBeNull,
+                                          IsKnownDeref, Visited);
+  } else if (auto *ASC = dyn_cast<AddrSpaceCastInst>(V)) {
+    DerefBytes = getPointerDereferenceableBytes(
+        ASC->getPointerOperand(), DL, CanBeNull, IsKnownDeref, 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 or dereferenceable bytes. Note that this is later
+    // overwritten if null pointers are defined.
+    const Value *Base = GEP->getPointerOperand();
+    uint64_t BaseDerefBytes = getPointerDereferenceableBytes(
+        Base, DL, CanBeNull, IsKnownDeref, 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();
+    }
+    // Assume dereferenceable implies nonnull here but note that we later revert
+    // the decision if it does not based on the pointer address space.
+    CanBeNull &= (DerefBytes == 0);
+  } 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))
+        DerefBytes = getPointerDereferenceableBytes(RP, DL, CanBeNull,
+                                                    IsKnownDeref, Visited);
+  }
 
-  if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V))
-    return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align, Size,
-                                              DL, CtxI, DT, Visited);
+  if (auto *I = dyn_cast<Instruction>(V))
+    F = I->getFunction();
 
-  if (const auto *Call = dyn_cast<CallBase>(V))
-    if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
-      return isDereferenceableAndAlignedPointer(RP, Align, Size, DL, CtxI, DT,
-                                                Visited);
+  IsKnownDeref = !CanBeNull;
+  CanBeNull |= NullPointerIsDefined(F, V->getType()->getPointerAddressSpace());
+  return DerefBytes;
+}
 
-  // If we don't know, assume the worst.
-  return false;
+uint64_t llvm::getPointerDereferenceableBytes(const Value *V,
+                                              const DataLayout &DL,
+                                              bool &CanBeNull,
+                                              bool &IsKnownDeref) {
+  SmallPtrSet<const Value *, 4> Visited;
+  return ::getPointerDereferenceableBytes(V, DL, CanBeNull, IsKnownDeref,
+                                          Visited);
 }
 
 bool llvm::isDereferenceableAndAlignedPointer(const Value *V, unsigned Align,
@@ -120,9 +311,17 @@
                                               const DataLayout &DL,
                                               const Instruction *CtxI,
                                               const DominatorTree *DT) {
-  SmallPtrSet<const Value *, 32> Visited;
-  return ::isDereferenceableAndAlignedPointer(V, Align, Size, DL, CtxI, DT,
-                                              Visited);
+  bool IsKnownDeref = false, CanBeNull = false;
+  APInt KnownDerefBytes(
+      Size.getBitWidth(),
+      getPointerDereferenceableBytes(V, DL, CanBeNull, IsKnownDeref));
+  if (KnownDerefBytes.getBoolValue())
+    if (KnownDerefBytes.uge(Size))
+      if (IsKnownDeref || 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,
@@ -142,11 +341,10 @@
   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,
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
@@ -1721,7 +1721,7 @@
 
   // 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));
   }
diff --git a/llvm/lib/CodeGen/CodeGenPrepare.cpp b/llvm/lib/CodeGen/CodeGenPrepare.cpp
--- a/llvm/lib/CodeGen/CodeGenPrepare.cpp
+++ b/llvm/lib/CodeGen/CodeGenPrepare.cpp
@@ -25,6 +25,7 @@
 #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"
@@ -1819,7 +1820,7 @@
       // 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);
@@ -1857,7 +1858,7 @@
     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;
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
@@ -19,6 +19,7 @@
 #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"
@@ -1125,10 +1126,38 @@
             isa<GlobalValue>(CE1->getOperand(0))) {
           GlobalValue *GV = cast<GlobalValue>(CE1->getOperand(0));
 
-          unsigned GVAlign;
+          unsigned GVAlign = 0;
 
           if (Module *TheModule = GV->getParent()) {
-            GVAlign = GV->getPointerAlignment(TheModule->getDataLayout());
+            const DataLayout &DL = TheModule->getDataLayout();
+            // Deduction of alignment is done via getPointerAlignment but that
+            // function is not accessible from the IR library so we copied the
+            // logic here.
+            if (isa<Function>(GV)) {
+              MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign();
+              GVAlign = FunctionPtrAlign ? FunctionPtrAlign->value() : 0;
+              switch (DL.getFunctionPtrAlignType()) {
+              case DataLayout::FunctionPtrAlignType::Independent:
+                break;
+              case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
+                GVAlign = std::max(GVAlign, GV->getAlignment());
+              }
+            }
+            if (GVAlign == 0) {
+              GVAlign = GV->getAlignment();
+              if (auto *GVar = dyn_cast<GlobalVariable>(GV)) {
+                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())
+                    GVAlign = DL.getPreferredAlignment(GVar);
+                  else
+                    GVAlign = DL.getABITypeAlignment(ObjectType);
+                }
+              }
+            }
 
             // If the function alignment is not specified then assume that it
             // is 4.
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
@@ -15,6 +15,7 @@
 #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"
@@ -609,139 +610,6 @@
   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);
diff --git a/llvm/lib/Target/AArch64/AArch64InstrInfo.h b/llvm/lib/Target/AArch64/AArch64InstrInfo.h
--- a/llvm/lib/Target/AArch64/AArch64InstrInfo.h
+++ b/llvm/lib/Target/AArch64/AArch64InstrInfo.h
@@ -17,6 +17,7 @@
 #include "AArch64RegisterInfo.h"
 #include "AArch64StackOffset.h"
 #include "llvm/ADT/Optional.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/CodeGen/MachineCombinerPattern.h"
 #include "llvm/CodeGen/TargetInstrInfo.h"
 
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
@@ -2188,7 +2188,7 @@
 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))
diff --git a/llvm/lib/Transforms/IPO/Attributor.cpp b/llvm/lib/Transforms/IPO/Attributor.cpp
--- a/llvm/lib/Transforms/IPO/Attributor.cpp
+++ b/llvm/lib/Transforms/IPO/Attributor.cpp
@@ -2058,8 +2058,9 @@
       if (!Stripped && this == &AA) {
         // Use IR information if we did not strip anything.
         // TODO: track globally.
-        bool CanBeNull;
-        DerefBytes = Base->getPointerDereferenceableBytes(DL, CanBeNull);
+        bool CanBeNull, IsKnownDeref;
+        DerefBytes =
+            getPointerDereferenceableBytes(Base, DL, CanBeNull, IsKnownDeref);
         T.GlobalState.indicatePessimisticFixpoint();
       } else {
         const DerefState &DS = static_cast<const DerefState &>(AA.getState());
@@ -2154,6 +2155,19 @@
       takeKnownMaximum(Attr.getValueAsInt());
   }
 
+  /// See AbstractAttribute::manifest(...).
+  ChangeStatus manifest(Attributor &A) override {
+    const Value &AssociatedVal = getAssociatedValue();
+    Type *Ty = isa<Function>(AssociatedVal)
+                   ? cast<Function>(AssociatedVal).getReturnType()
+                   : AssociatedVal.getType()->getPointerElementType();
+    if (Ty->isSized() &&
+        getAssumed() <= A.getDataLayout().getABITypeAlignment(Ty))
+      return ChangeStatus::UNCHANGED;
+
+    return AAAlign::manifest(A);
+  }
+
   /// See AbstractAttribute::getDeducedAttributes
   virtual void
   getDeducedAttributes(LLVMContext &Ctx,
@@ -2208,7 +2222,7 @@
       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.
diff --git a/llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll b/llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll
--- a/llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll
+++ b/llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll
@@ -1,6 +1,5 @@
 ; NOTE: Assertions have been autogenerated by utils/update_llc_test_checks.py
-; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown \
-; RUN:   -verify-machineinstrs -O2 < %s | FileCheck %s
+; RUN: llc -mcpu=pwr9 -mtriple=powerpc64le-unknown-unknown  -verify-machineinstrs -O2 < %s | FileCheck %s
 $test = comdat any
 
 ; Function Attrs: noinline nounwind
@@ -8,10 +7,8 @@
 ; CHECK-LABEL: test:
 ; CHECK:       # %bb.0: # %entry
 ; CHECK-NEXT:    ld 3, 0(3)
-; CHECK-NEXT:    cmpdi 1, 3, 0
-; CHECK-NEXT:    andi. 4, 3, 3
-; CHECK-NEXT:    crand 20, 2, 5
-; CHECK-NEXT:    isel 3, 0, 3, 20
+; CHECK-NEXT:    cmpdi 3, 0
+; CHECK-NEXT:    isel 3, 0, 3, 1
 ; CHECK-NEXT:    addi 3, 3, -1
 ; CHECK-NEXT:    cmpldi 3, 3
 ; CHECK-NEXT:    bltlr+ 0
@@ -94,6 +91,13 @@
 }
 
 define i64 @andis_no_cmp(i64 %a, i64 %b) {
+; CHECK-LABEL: andis_no_cmp:
+; CHECK:       # %bb.0: # %entry
+; CHECK-NEXT:    andis. 5, 3, 1
+; CHECK-NEXT:    li 5, 1
+; CHECK-NEXT:    isel 4, 4, 5, 2
+; CHECK-NEXT:    mulld 3, 4, 3
+; CHECK-NEXT:    blr
 entry:
   %and = and i64 %a, 65536
   %tobool = icmp eq i64 %and, 0
diff --git a/llvm/test/Transforms/FunctionAttrs/align.ll b/llvm/test/Transforms/FunctionAttrs/align.ll
--- a/llvm/test/Transforms/FunctionAttrs/align.ll
+++ b/llvm/test/Transforms/FunctionAttrs/align.ll
@@ -7,8 +7,8 @@
 
 
 ; TEST 1
-; ATTRIBUTOR: define align 8 i32* @test1(i32* returned align 8 %0)
-define i32* @test1(i32* align 8 %0) #0 {
+; ATTRIBUTOR: define align 16 i32* @test1(i32* returned align 16 %0)
+define i32* @test1(i32* align 16 %0) #0 {
   ret i32* %0
 }
 
@@ -19,8 +19,8 @@
 }
 
 ; TEST 3
-; ATTRIBUTOR: define align 4 i32* @test3(i32* align 8 %0, i32* align 4 %1, i1 %2)
-define i32* @test3(i32* align 8 %0, i32* align 4 %1, i1 %2) #0 {
+; ATTRIBUTOR: define align 16 i32* @test3(i32* align 32 %0, i32* align 16 %1, i1 %2)
+define i32* @test3(i32* align 32 %0, i32* align 16 %1, i1 %2) #0 {
   %ret = select i1 %2, i32* %0, i32* %1
   ret i32* %ret
 }
@@ -34,18 +34,18 @@
 
 ; TEST 5
 declare i32* @unknown()
-declare align 8 i32* @align8()
+declare align 32 i32* @align32()
 
 
-; ATTRIBUTOR: define align 8 i32* @test5_1()
+; ATTRIBUTOR: define align 32 i32* @test5_1()
 define i32* @test5_1() {
-  %ret = tail call align 8 i32* @unknown()
+  %ret = tail call align 32 i32* @unknown()
   ret i32* %ret
 }
 
-; ATTRIBUTOR: define align 8 i32* @test5_2()
+; ATTRIBUTOR: define align 32 i32* @test5_2()
 define i32* @test5_2() {
-  %ret = tail call i32* @align8()
+  %ret = tail call i32* @align32()
   ret i32* %ret
 }
 
@@ -78,17 +78,17 @@
 ;     return a?&a1: f1(&a2);
 ; }
 
-@a1 = common global i8 0, align 8
-@a2 = common global i8 0, align 16
+@a1 = common global i8 0, align 16
+@a2 = common global i8 0, align 32
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f1(i8* readnone %0) local_unnamed_addr #0 {
-; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f1(i8* nonnull readnone align 8 dereferenceable(1) %0)
+; ATTRIBUTOR: define internal nonnull align 16 dereferenceable(1) i8* @f1(i8* nonnull readnone align 16 dereferenceable(1) %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call i8* @f2(i8* nonnull align 8 dereferenceable(1) @a1)
+; ATTRIBUTOR: %4 = tail call i8* @f2(i8* nonnull align 16 dereferenceable(1) @a1)
   %4 = tail call i8* @f2(i8* nonnull @a1)
   br label %5
 
@@ -99,18 +99,18 @@
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f2(i8* readnone %0) local_unnamed_addr #0 {
-; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f2(i8* nonnull readnone align 8 dereferenceable(1) %0)
+; ATTRIBUTOR: define internal nonnull align 16 dereferenceable(1) i8* @f2(i8* nonnull readnone align 16 dereferenceable(1) %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %5, label %3
 
 ; <label>:3:                                      ; preds = %1
 
-; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 8 dereferenceable(1) %0)
+; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 16 dereferenceable(1) %0)
   %4 = tail call i8* @f1(i8* nonnull %0)
   br label %7
 
 ; <label>:5:                                      ; preds = %1
-; ATTRIBUTOR: %6 = tail call i8* @f3(i8* nonnull align 16 dereferenceable(1) @a2)
+; ATTRIBUTOR: %6 = tail call i8* @f3(i8* nonnull align 32 dereferenceable(1) @a2)
   %6 = tail call i8* @f3(i8* nonnull @a2)
   br label %7
 
@@ -121,12 +121,12 @@
 
 ; Function Attrs: nounwind readnone ssp uwtable
 define internal i8* @f3(i8* readnone %0) local_unnamed_addr #0 {
-; ATTRIBUTOR: define internal nonnull align 8 dereferenceable(1) i8* @f3(i8* nonnull readnone align 16 dereferenceable(1) %0)
+; ATTRIBUTOR: define internal nonnull align 16 dereferenceable(1) i8* @f3(i8* nonnull readnone align 32 dereferenceable(1) %0)
   %2 = icmp eq i8* %0, null
   br i1 %2, label %3, label %5
 
 ; <label>:3:                                      ; preds = %1
-; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 16 dereferenceable(1) @a2)
+; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 32 dereferenceable(1) @a2)
   %4 = tail call i8* @f1(i8* nonnull @a2)
   br label %5
 
@@ -147,20 +147,20 @@
 ; TEST 8
 define void @test8_helper() {
   %ptr0 = tail call i32* @unknown()
-  %ptr1 = tail call align 4 i32* @unknown()
-  %ptr2 = tail call align 8 i32* @unknown()
+  %ptr1 = tail call align 8 i32* @unknown()
+  %ptr2 = tail call align 16 i32* @unknown()
 
   tail call void @test8(i32* %ptr1, i32* %ptr1, i32* %ptr0)
-; ATTRIBUTOR: tail call void @test8(i32* align 4 %ptr1, i32* align 4 %ptr1, i32* %ptr0)
+; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr1, i32* align 8 %ptr1, i32* %ptr0)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
-; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr2, i32* align 4 %ptr1, i32* align 4 %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* align 16 %ptr2, i32* align 8 %ptr1, i32* align 8 %ptr1)
   tail call void @test8(i32* %ptr2, i32* %ptr1, i32* %ptr1)
-; ATTRIBUTOR: tail call void @test8(i32* align 8 %ptr2, i32* align 4 %ptr1, i32* align 4 %ptr1)
+; ATTRIBUTOR: tail call void @test8(i32* align 16 %ptr2, i32* align 8 %ptr1, i32* align 8 %ptr1)
   ret void
 }
 
 define internal void @test8(i32* %a, i32* %b, i32* %c) {
-; ATTRIBUTOR: define internal void @test8(i32* align 4 %a, i32* align 4 %b, i32* %c)
+; ATTRIBUTOR: define internal void @test8(i32* align 8 %a, i32* align 8 %b, i32* %c)
   ret void
 }
 
diff --git a/llvm/test/Transforms/FunctionAttrs/noalias_returned.ll b/llvm/test/Transforms/FunctionAttrs/noalias_returned.ll
--- a/llvm/test/Transforms/FunctionAttrs/noalias_returned.ll
+++ b/llvm/test/Transforms/FunctionAttrs/noalias_returned.ll
@@ -79,13 +79,13 @@
 ; TEST 5
 
 ; Returning global pointer. Should not be noalias.
-; CHECK: define nonnull align 8 dereferenceable(8) i8** @getter()
+; CHECK: define nonnull dereferenceable(8) i8** @getter()
 define i8** @getter() {
   ret i8** @G
 }
 
 ; Returning global pointer. Should not be noalias.
-; CHECK: define nonnull align 8 dereferenceable(8) i8** @calle1()
+; CHECK: define nonnull dereferenceable(8) i8** @calle1()
 define i8** @calle1(){
   %1 = call i8** @getter()
   ret i8** %1
diff --git a/llvm/test/Transforms/InstCombine/PowerPC/aligned-altivec.ll b/llvm/test/Transforms/InstCombine/PowerPC/aligned-altivec.ll
--- a/llvm/test/Transforms/InstCombine/PowerPC/aligned-altivec.ll
+++ b/llvm/test/Transforms/InstCombine/PowerPC/aligned-altivec.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine < %s | FileCheck %s
 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-v128:128:128-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
@@ -5,14 +6,19 @@
 declare <4 x i32> @llvm.ppc.altivec.lvx(i8*) #1
 
 define <4 x i32> @test1(<4 x i32>* %h) #0 {
+; CHECK-LABEL: @test1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[VL:%.*]] = load <4 x i32>, <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    [[A:%.*]] = add <4 x i32> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x i32> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
   %vl = call <4 x i32> @llvm.ppc.altivec.lvx(i8* %hv)
 
-; CHECK-LABEL: @test1
-; CHECK: @llvm.ppc.altivec.lvx
-; CHECK: ret <4 x i32>
 
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   %a = add <4 x i32> %v0, %vl
@@ -20,14 +26,19 @@
 }
 
 define <4 x i32> @test1a(<4 x i32>* align 16 %h) #0 {
+; CHECK-LABEL: @test1a(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[VL:%.*]] = load <4 x i32>, <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    [[A:%.*]] = add <4 x i32> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x i32> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
   %vl = call <4 x i32> @llvm.ppc.altivec.lvx(i8* %hv)
 
-; CHECK-LABEL: @test1a
-; CHECK-NOT: @llvm.ppc.altivec.lvx
-; CHECK: ret <4 x i32>
 
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   %a = add <4 x i32> %v0, %vl
@@ -37,6 +48,13 @@
 declare void @llvm.ppc.altivec.stvx(<4 x i32>, i8*) #0
 
 define <4 x i32> @test2(<4 x i32>* %h, <4 x i32> %d) #0 {
+; CHECK-LABEL: @test2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    store <4 x i32> [[D:%.*]], <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x i32> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
@@ -45,12 +63,16 @@
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   ret <4 x i32> %v0
 
-; CHECK-LABEL: @test2
-; CHECK: @llvm.ppc.altivec.stvx
-; CHECK: ret <4 x i32>
 }
 
 define <4 x i32> @test2a(<4 x i32>* align 16 %h, <4 x i32> %d) #0 {
+; CHECK-LABEL: @test2a(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    store <4 x i32> [[D:%.*]], <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x i32> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
@@ -59,22 +81,24 @@
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   ret <4 x i32> %v0
 
-; CHECK-LABEL: @test2
-; CHECK-NOT: @llvm.ppc.altivec.stvx
-; CHECK: ret <4 x i32>
 }
 
 declare <4 x i32> @llvm.ppc.altivec.lvxl(i8*) #1
 
 define <4 x i32> @test1l(<4 x i32>* %h) #0 {
+; CHECK-LABEL: @test1l(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[VL:%.*]] = load <4 x i32>, <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    [[A:%.*]] = add <4 x i32> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x i32> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
   %vl = call <4 x i32> @llvm.ppc.altivec.lvxl(i8* %hv)
 
-; CHECK-LABEL: @test1l
-; CHECK: @llvm.ppc.altivec.lvxl
-; CHECK: ret <4 x i32>
 
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   %a = add <4 x i32> %v0, %vl
@@ -82,14 +106,19 @@
 }
 
 define <4 x i32> @test1la(<4 x i32>* align 16 %h) #0 {
+; CHECK-LABEL: @test1la(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[VL:%.*]] = load <4 x i32>, <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    [[A:%.*]] = add <4 x i32> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x i32> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
   %vl = call <4 x i32> @llvm.ppc.altivec.lvxl(i8* %hv)
 
-; CHECK-LABEL: @test1la
-; CHECK-NOT: @llvm.ppc.altivec.lvxl
-; CHECK: ret <4 x i32>
 
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   %a = add <4 x i32> %v0, %vl
@@ -99,6 +128,13 @@
 declare void @llvm.ppc.altivec.stvxl(<4 x i32>, i8*) #0
 
 define <4 x i32> @test2l(<4 x i32>* %h, <4 x i32> %d) #0 {
+; CHECK-LABEL: @test2l(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    store <4 x i32> [[D:%.*]], <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x i32> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
@@ -107,12 +143,16 @@
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   ret <4 x i32> %v0
 
-; CHECK-LABEL: @test2l
-; CHECK: @llvm.ppc.altivec.stvxl
-; CHECK: ret <4 x i32>
 }
 
 define <4 x i32> @test2la(<4 x i32>* align 16 %h, <4 x i32> %d) #0 {
+; CHECK-LABEL: @test2la(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x i32>, <4 x i32>* [[H:%.*]], i64 1
+; CHECK-NEXT:    store <4 x i32> [[D:%.*]], <4 x i32>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x i32>, <4 x i32>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x i32> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x i32>, <4 x i32>* %h, i64 1
   %hv = bitcast <4 x i32>* %h1 to i8*
@@ -121,9 +161,6 @@
   %v0 = load <4 x i32>, <4 x i32>* %h, align 8
   ret <4 x i32> %v0
 
-; CHECK-LABEL: @test2l
-; CHECK-NOT: @llvm.ppc.altivec.stvxl
-; CHECK: ret <4 x i32>
 }
 
 attributes #0 = { nounwind }
diff --git a/llvm/test/Transforms/InstCombine/PowerPC/aligned-qpx.ll b/llvm/test/Transforms/InstCombine/PowerPC/aligned-qpx.ll
--- a/llvm/test/Transforms/InstCombine/PowerPC/aligned-qpx.ll
+++ b/llvm/test/Transforms/InstCombine/PowerPC/aligned-qpx.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine < %s | FileCheck %s
 target datalayout = "E-p:64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-f128:128:128-v128:128:128-n32:64"
 target triple = "powerpc64-unknown-linux-gnu"
@@ -5,14 +6,21 @@
 declare <4 x double> @llvm.ppc.qpx.qvlfs(i8*) #1
 
 define <4 x double> @test1(<4 x float>* %h) #0 {
+; CHECK-LABEL: @test1(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x float>, <4 x float>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[TMP0:%.*]] = load <4 x float>, <4 x float>* [[H1]], align 16
+; CHECK-NEXT:    [[VL:%.*]] = fpext <4 x float> [[TMP0]] to <4 x double>
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x float>, <4 x float>* [[H]], align 16
+; CHECK-NEXT:    [[V0E:%.*]] = fpext <4 x float> [[V0]] to <4 x double>
+; CHECK-NEXT:    [[A:%.*]] = fadd <4 x double> [[V0E]], [[VL]]
+; CHECK-NEXT:    ret <4 x double> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x float>, <4 x float>* %h, i64 1
   %hv = bitcast <4 x float>* %h1 to i8*
   %vl = call <4 x double> @llvm.ppc.qpx.qvlfs(i8* %hv)
 
-; CHECK-LABEL: @test1
-; CHECK: @llvm.ppc.qpx.qvlfs
-; CHECK: ret <4 x double>
 
   %v0 = load <4 x float>, <4 x float>* %h, align 8
   %v0e = fpext <4 x float> %v0 to <4 x double>
@@ -21,15 +29,21 @@
 }
 
 define <4 x double> @test1a(<4 x float>* align 16 %h) #0 {
+; CHECK-LABEL: @test1a(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x float>, <4 x float>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[TMP0:%.*]] = load <4 x float>, <4 x float>* [[H1]], align 16
+; CHECK-NEXT:    [[VL:%.*]] = fpext <4 x float> [[TMP0]] to <4 x double>
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x float>, <4 x float>* [[H]], align 16
+; CHECK-NEXT:    [[V0E:%.*]] = fpext <4 x float> [[V0]] to <4 x double>
+; CHECK-NEXT:    [[A:%.*]] = fadd <4 x double> [[V0E]], [[VL]]
+; CHECK-NEXT:    ret <4 x double> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x float>, <4 x float>* %h, i64 1
   %hv = bitcast <4 x float>* %h1 to i8*
   %vl = call <4 x double> @llvm.ppc.qpx.qvlfs(i8* %hv)
 
-; CHECK-LABEL: @test1a
-; CHECK-NOT: @llvm.ppc.qpx.qvlfs
-; CHECK-NOT: load <4 x double>
-; CHECK: ret <4 x double>
 
   %v0 = load <4 x float>, <4 x float>* %h, align 8
   %v0e = fpext <4 x float> %v0 to <4 x double>
@@ -40,6 +54,14 @@
 declare void @llvm.ppc.qpx.qvstfs(<4 x double>, i8*) #0
 
 define <4 x float> @test2(<4 x float>* %h, <4 x double> %d) #0 {
+; CHECK-LABEL: @test2(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x float>, <4 x float>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[TMP0:%.*]] = fptrunc <4 x double> [[D:%.*]] to <4 x float>
+; CHECK-NEXT:    store <4 x float> [[TMP0]], <4 x float>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x float>, <4 x float>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x float> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x float>, <4 x float>* %h, i64 1
   %hv = bitcast <4 x float>* %h1 to i8*
@@ -48,12 +70,17 @@
   %v0 = load <4 x float>, <4 x float>* %h, align 8
   ret <4 x float> %v0
 
-; CHECK-LABEL: @test2
-; CHECK: @llvm.ppc.qpx.qvstfs
-; CHECK: ret <4 x float>
 }
 
 define <4 x float> @test2a(<4 x float>* align 16 %h, <4 x double> %d) #0 {
+; CHECK-LABEL: @test2a(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x float>, <4 x float>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[TMP0:%.*]] = fptrunc <4 x double> [[D:%.*]] to <4 x float>
+; CHECK-NEXT:    store <4 x float> [[TMP0]], <4 x float>* [[H1]], align 16
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x float>, <4 x float>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x float> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x float>, <4 x float>* %h, i64 1
   %hv = bitcast <4 x float>* %h1 to i8*
@@ -62,24 +89,24 @@
   %v0 = load <4 x float>, <4 x float>* %h, align 8
   ret <4 x float> %v0
 
-; CHECK-LABEL: @test2
-; CHECK: fptrunc <4 x double> %d to <4 x float>
-; CHECK-NOT: @llvm.ppc.qpx.qvstfs
-; CHECK-NOT: store <4 x double>
-; CHECK: ret <4 x float>
 }
 
 declare <4 x double> @llvm.ppc.qpx.qvlfd(i8*) #1
 
 define <4 x double> @test1l(<4 x double>* %h) #0 {
+; CHECK-LABEL: @test1l(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x double>, <4 x double>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[VL:%.*]] = load <4 x double>, <4 x double>* [[H1]], align 32
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x double>, <4 x double>* [[H]], align 32
+; CHECK-NEXT:    [[A:%.*]] = fadd <4 x double> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x double> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x double>, <4 x double>* %h, i64 1
   %hv = bitcast <4 x double>* %h1 to i8*
   %vl = call <4 x double> @llvm.ppc.qpx.qvlfd(i8* %hv)
 
-; CHECK-LABEL: @test1l
-; CHECK: @llvm.ppc.qpx.qvlfd
-; CHECK: ret <4 x double>
 
   %v0 = load <4 x double>, <4 x double>* %h, align 8
   %a = fadd <4 x double> %v0, %vl
@@ -87,14 +114,20 @@
 }
 
 define <4 x double> @test1ln(<4 x double>* align 16 %h) #0 {
+; CHECK-LABEL: @test1ln(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x double>, <4 x double>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[HV:%.*]] = bitcast <4 x double>* [[H1]] to i8*
+; CHECK-NEXT:    [[VL:%.*]] = call <4 x double> @llvm.ppc.qpx.qvlfd(i8* [[HV]])
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x double>, <4 x double>* [[H]], align 16
+; CHECK-NEXT:    [[A:%.*]] = fadd <4 x double> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x double> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x double>, <4 x double>* %h, i64 1
   %hv = bitcast <4 x double>* %h1 to i8*
   %vl = call <4 x double> @llvm.ppc.qpx.qvlfd(i8* %hv)
 
-; CHECK-LABEL: @test1ln
-; CHECK: @llvm.ppc.qpx.qvlfd
-; CHECK: ret <4 x double>
 
   %v0 = load <4 x double>, <4 x double>* %h, align 8
   %a = fadd <4 x double> %v0, %vl
@@ -102,14 +135,19 @@
 }
 
 define <4 x double> @test1la(<4 x double>* align 32 %h) #0 {
+; CHECK-LABEL: @test1la(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x double>, <4 x double>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[VL:%.*]] = load <4 x double>, <4 x double>* [[H1]], align 32
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x double>, <4 x double>* [[H]], align 32
+; CHECK-NEXT:    [[A:%.*]] = fadd <4 x double> [[V0]], [[VL]]
+; CHECK-NEXT:    ret <4 x double> [[A]]
+;
 entry:
   %h1 = getelementptr <4 x double>, <4 x double>* %h, i64 1
   %hv = bitcast <4 x double>* %h1 to i8*
   %vl = call <4 x double> @llvm.ppc.qpx.qvlfd(i8* %hv)
 
-; CHECK-LABEL: @test1la
-; CHECK-NOT: @llvm.ppc.qpx.qvlfd
-; CHECK: ret <4 x double>
 
   %v0 = load <4 x double>, <4 x double>* %h, align 8
   %a = fadd <4 x double> %v0, %vl
@@ -119,6 +157,13 @@
 declare void @llvm.ppc.qpx.qvstfd(<4 x double>, i8*) #0
 
 define <4 x double> @test2l(<4 x double>* %h, <4 x double> %d) #0 {
+; CHECK-LABEL: @test2l(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x double>, <4 x double>* [[H:%.*]], i64 1
+; CHECK-NEXT:    store <4 x double> [[D:%.*]], <4 x double>* [[H1]], align 32
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x double>, <4 x double>* [[H]], align 32
+; CHECK-NEXT:    ret <4 x double> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x double>, <4 x double>* %h, i64 1
   %hv = bitcast <4 x double>* %h1 to i8*
@@ -127,12 +172,17 @@
   %v0 = load <4 x double>, <4 x double>* %h, align 8
   ret <4 x double> %v0
 
-; CHECK-LABEL: @test2l
-; CHECK: @llvm.ppc.qpx.qvstfd
-; CHECK: ret <4 x double>
 }
 
 define <4 x double> @test2ln(<4 x double>* align 16 %h, <4 x double> %d) #0 {
+; CHECK-LABEL: @test2ln(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x double>, <4 x double>* [[H:%.*]], i64 1
+; CHECK-NEXT:    [[HV:%.*]] = bitcast <4 x double>* [[H1]] to i8*
+; CHECK-NEXT:    call void @llvm.ppc.qpx.qvstfd(<4 x double> [[D:%.*]], i8* [[HV]])
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x double>, <4 x double>* [[H]], align 16
+; CHECK-NEXT:    ret <4 x double> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x double>, <4 x double>* %h, i64 1
   %hv = bitcast <4 x double>* %h1 to i8*
@@ -141,12 +191,16 @@
   %v0 = load <4 x double>, <4 x double>* %h, align 8
   ret <4 x double> %v0
 
-; CHECK-LABEL: @test2ln
-; CHECK: @llvm.ppc.qpx.qvstfd
-; CHECK: ret <4 x double>
 }
 
 define <4 x double> @test2la(<4 x double>* align 32 %h, <4 x double> %d) #0 {
+; CHECK-LABEL: @test2la(
+; CHECK-NEXT:  entry:
+; CHECK-NEXT:    [[H1:%.*]] = getelementptr <4 x double>, <4 x double>* [[H:%.*]], i64 1
+; CHECK-NEXT:    store <4 x double> [[D:%.*]], <4 x double>* [[H1]], align 32
+; CHECK-NEXT:    [[V0:%.*]] = load <4 x double>, <4 x double>* [[H]], align 32
+; CHECK-NEXT:    ret <4 x double> [[V0]]
+;
 entry:
   %h1 = getelementptr <4 x double>, <4 x double>* %h, i64 1
   %hv = bitcast <4 x double>* %h1 to i8*
@@ -155,9 +209,6 @@
   %v0 = load <4 x double>, <4 x double>* %h, align 8
   ret <4 x double> %v0
 
-; CHECK-LABEL: @test2l
-; CHECK-NOT: @llvm.ppc.qpx.qvstfd
-; CHECK: ret <4 x double>
 }
 
 attributes #0 = { nounwind }
diff --git a/llvm/test/Transforms/InstCombine/assume_inevitable.ll b/llvm/test/Transforms/InstCombine/assume_inevitable.ll
--- a/llvm/test/Transforms/InstCombine/assume_inevitable.ll
+++ b/llvm/test/Transforms/InstCombine/assume_inevitable.ll
@@ -20,7 +20,7 @@
 ; CHECK-NEXT:    [[OBJSZ:%.*]] = call i64 @llvm.objectsize.i64.p0i8(i8* [[C:%.*]], i1 false, i1 false, i1 false)
 ; CHECK-NEXT:    store i64 [[OBJSZ]], i64* [[M_X]], align 4
 ; CHECK-NEXT:    [[PTRINT:%.*]] = ptrtoint i32* [[A]] to i64
-; CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 31
+; CHECK-NEXT:    [[MASKEDPTR:%.*]] = and i64 [[PTRINT]], 28
 ; CHECK-NEXT:    [[MASKCOND:%.*]] = icmp eq i64 [[MASKEDPTR]], 0
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[MASKCOND]])
 ; CHECK-NEXT:    ret i32 [[TMP0]]
diff --git a/llvm/test/Transforms/InstCombine/atomic.ll b/llvm/test/Transforms/InstCombine/atomic.ll
--- a/llvm/test/Transforms/InstCombine/atomic.ll
+++ b/llvm/test/Transforms/InstCombine/atomic.ll
@@ -274,7 +274,7 @@
 
 define i32 @test20(i32** %p, i8* %v) {
 ; CHECK-LABEL: define i32 @test20(
-; CHECK: store atomic i8* %v, i8** [[D:%.*]] unordered, align 4
+; CHECK: store atomic i8* %v, i8** [[D:%.*]] unordered, align 8
   %cast = bitcast i8* %v to i32*
   store atomic i32* %cast, i32** %p unordered, align 4
   ret i32 0
@@ -282,7 +282,7 @@
 
 define i32 @test21(i32** %p, i8* %v) {
 ; CHECK-LABEL: define i32 @test21(
-; CHECK: store atomic i32* %cast, i32** %p monotonic, align 4
+; CHECK: store atomic i32* %cast, i32** %p monotonic, align 8
   %cast = bitcast i8* %v to i32*
   store atomic i32* %cast, i32** %p monotonic, align 4
   ret i32 0
diff --git a/llvm/test/Transforms/InstCombine/constant-fold-address-space-pointer.ll b/llvm/test/Transforms/InstCombine/constant-fold-address-space-pointer.ll
--- a/llvm/test/Transforms/InstCombine/constant-fold-address-space-pointer.ll
+++ b/llvm/test/Transforms/InstCombine/constant-fold-address-space-pointer.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S -instcombine %s -o - | FileCheck %s
 target datalayout = "e-p:32:32:32-p1:64:64:64-p2:8:8:8-p3:16:16:16-p4:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:32"
 
@@ -16,7 +17,8 @@
 ; The intermediate integer size is the same as the pointer size
 define i32 addrspace(3)* @test_constant_fold_inttoptr_as_pointer_same_size() {
 ; CHECK-LABEL: @test_constant_fold_inttoptr_as_pointer_same_size(
-; CHECK-NEXT: ret i32 addrspace(3)* @const_zero_i32_as3
+; CHECK-NEXT:    ret i32 addrspace(3)* @const_zero_i32_as3
+;
   %x = ptrtoint i32 addrspace(3)* @const_zero_i32_as3 to i32
   %y = inttoptr i32 %x to i32 addrspace(3)*
   ret i32 addrspace(3)* %y
@@ -25,7 +27,8 @@
 ; The intermediate integer size is larger than the pointer size
 define i32 addrspace(2)* @test_constant_fold_inttoptr_as_pointer_smaller() {
 ; CHECK-LABEL: @test_constant_fold_inttoptr_as_pointer_smaller(
-; CHECK-NEXT: ret i32 addrspace(2)* @const_zero_i32_as2
+; CHECK-NEXT:    ret i32 addrspace(2)* @const_zero_i32_as2
+;
   %x = ptrtoint i32 addrspace(2)* @const_zero_i32_as2 to i16
   %y = inttoptr i16 %x to i32 addrspace(2)*
   ret i32 addrspace(2)* %y
@@ -35,7 +38,8 @@
 ; different so nothing should happen
 define i32 addrspace(4)* @test_constant_fold_inttoptr_as_pointer_smaller_different_as() {
 ; CHECK-LABEL: @test_constant_fold_inttoptr_as_pointer_smaller_different_as(
-; CHECK-NEXT: ret i32 addrspace(4)* inttoptr (i16 ptrtoint (i32 addrspace(3)* @const_zero_i32_as3 to i16) to i32 addrspace(4)*)
+; CHECK-NEXT:    ret i32 addrspace(4)* inttoptr (i16 ptrtoint (i32 addrspace(3)* @const_zero_i32_as3 to i16) to i32 addrspace(4)*)
+;
   %x = ptrtoint i32 addrspace(3)* @const_zero_i32_as3 to i16
   %y = inttoptr i16 %x to i32 addrspace(4)*
   ret i32 addrspace(4)* %y
@@ -45,7 +49,8 @@
 ; address spaces when folding this
 define i32 addrspace(2)* @test_constant_fold_inttoptr_as_pointer_smaller_different_size_as() {
 ; CHECK-LABEL: @test_constant_fold_inttoptr_as_pointer_smaller_different_size_as(
-; CHECK-NEXT: ret i32 addrspace(2)* inttoptr (i32 ptrtoint (i32 addrspace(3)* @const_zero_i32_as3 to i32) to i32 addrspace(2)*)
+; CHECK-NEXT:    ret i32 addrspace(2)* inttoptr (i32 ptrtoint (i32 addrspace(3)* @const_zero_i32_as3 to i32) to i32 addrspace(2)*)
+;
   %x = ptrtoint i32 addrspace(3)* @const_zero_i32_as3 to i32
   %y = inttoptr i32 %x to i32 addrspace(2)*
   ret i32 addrspace(2)* %y
@@ -54,7 +59,8 @@
 ; The intermediate integer size is too small, nothing should happen
 define i32 addrspace(3)* @test_constant_fold_inttoptr_as_pointer_larger() {
 ; CHECK-LABEL: @test_constant_fold_inttoptr_as_pointer_larger(
-; CHECK-NEXT: ret i32 addrspace(3)* inttoptr (i8 ptrtoint (i32 addrspace(3)* @const_zero_i32_as3 to i8) to i32 addrspace(3)*)
+; CHECK-NEXT:    ret i32 addrspace(3)* inttoptr (i8 ptrtoint (i32 addrspace(3)* @const_zero_i32_as3 to i8) to i32 addrspace(3)*)
+;
   %x = ptrtoint i32 addrspace(3)* @const_zero_i32_as3 to i8
   %y = inttoptr i8 %x to i32 addrspace(3)*
   ret i32 addrspace(3)* %y
@@ -62,7 +68,8 @@
 
 define i8 @const_fold_ptrtoint() {
 ; CHECK-LABEL: @const_fold_ptrtoint(
-; CHECK-NEXT: ret i8 4
+; CHECK-NEXT:    ret i8 4
+;
   ret i8 ptrtoint (i32 addrspace(2)* inttoptr (i4 4 to i32 addrspace(2)*) to i8)
 }
 
@@ -70,7 +77,8 @@
 ; the original
 define i8 @const_fold_ptrtoint_mask() {
 ; CHECK-LABEL: @const_fold_ptrtoint_mask(
-; CHECK-NEXT: ret i8 1
+; CHECK-NEXT:    ret i8 1
+;
   ret i8 ptrtoint (i32 addrspace(3)* inttoptr (i32 257 to i32 addrspace(3)*) to i8)
 }
 
@@ -78,68 +86,78 @@
 ; 64-bits instead of 32
 define i64 @const_fold_ptrtoint_mask_small_as0() {
 ; CHECK-LABEL: @const_fold_ptrtoint_mask_small_as0(
-; CHECK: ret i64 -1
+; CHECK-NEXT:    ret i64 -1
+;
   ret i64 ptrtoint (i32 addrspace(1)* inttoptr (i128 -1 to i32 addrspace(1)*) to i64)
 }
 
 define i32 addrspace(3)* @const_inttoptr() {
 ; CHECK-LABEL: @const_inttoptr(
-; CHECK-NEXT: ret i32 addrspace(3)* inttoptr (i16 4 to i32 addrspace(3)*)
+; CHECK-NEXT:    ret i32 addrspace(3)* inttoptr (i16 4 to i32 addrspace(3)*)
+;
   %p = inttoptr i16 4 to i32 addrspace(3)*
   ret i32 addrspace(3)* %p
 }
 
 define i16 @const_ptrtoint() {
 ; CHECK-LABEL: @const_ptrtoint(
-; CHECK-NEXT: ret i16 ptrtoint (i32 addrspace(3)* @g to i16)
+; CHECK-NEXT:    ret i16 ptrtoint (i32 addrspace(3)* @g to i16)
+;
   %i = ptrtoint i32 addrspace(3)* @g to i16
   ret i16 %i
 }
 
 define i16 @const_inttoptr_ptrtoint() {
 ; CHECK-LABEL: @const_inttoptr_ptrtoint(
-; CHECK-NEXT: ret i16 9
+; CHECK-NEXT:    ret i16 9
+;
   ret i16 ptrtoint (i32 addrspace(3)* inttoptr (i16 9 to i32 addrspace(3)*) to i16)
 }
 
 define i1 @constant_fold_cmp_constantexpr_inttoptr() {
 ; CHECK-LABEL: @constant_fold_cmp_constantexpr_inttoptr(
-; CHECK-NEXT: ret i1 true
+; CHECK-NEXT:    ret i1 true
+;
   %x = icmp eq i32 addrspace(3)* inttoptr (i16 0 to i32 addrspace(3)*), null
   ret i1 %x
 }
 
 define i1 @constant_fold_inttoptr_null(i16 %i) {
 ; CHECK-LABEL: @constant_fold_inttoptr_null(
-; CHECK-NEXT: ret i1 false
+; CHECK-NEXT:    ret i1 false
+;
   %x = icmp eq i32 addrspace(3)* inttoptr (i16 99 to i32 addrspace(3)*), inttoptr (i16 0 to i32 addrspace(3)*)
   ret i1 %x
 }
 
 define i1 @constant_fold_ptrtoint_null() {
 ; CHECK-LABEL: @constant_fold_ptrtoint_null(
-; CHECK-NEXT: ret i1 icmp eq (i32 addrspace(3)* @g, i32 addrspace(3)* null)
+; CHECK-NEXT:    ret i1 icmp eq (i32 addrspace(3)* @g, i32 addrspace(3)* null)
+;
   %x = icmp eq i16 ptrtoint (i32 addrspace(3)* @g to i16), ptrtoint (i32 addrspace(3)* null to i16)
   ret i1 %x
 }
 
 define i1 @constant_fold_ptrtoint_null_2() {
 ; CHECK-LABEL: @constant_fold_ptrtoint_null_2(
-; CHECK-NEXT: ret i1 icmp eq (i32 addrspace(3)* @g, i32 addrspace(3)* null)
+; CHECK-NEXT:    ret i1 icmp eq (i32 addrspace(3)* @g, i32 addrspace(3)* null)
+;
   %x = icmp eq i16 ptrtoint (i32 addrspace(3)* null to i16), ptrtoint (i32 addrspace(3)* @g to i16)
   ret i1 %x
 }
 
 define i1 @constant_fold_ptrtoint() {
 ; CHECK-LABEL: @constant_fold_ptrtoint(
-; CHECK-NEXT: ret i1 true
+; CHECK-NEXT:    ret i1 true
+;
   %x = icmp eq i16 ptrtoint (i32 addrspace(3)* @g to i16), ptrtoint (i32 addrspace(3)* @g to i16)
   ret i1 %x
 }
 
 define i1 @constant_fold_inttoptr() {
 ; CHECK-LABEL: @constant_fold_inttoptr(
-; CHECK-NEXT: ret i1 false
+; CHECK-NEXT:    ret i1 false
+;
   %x = icmp eq i32 addrspace(3)* inttoptr (i16 99 to i32 addrspace(3)*), inttoptr (i16 27 to i32 addrspace(3)*)
   ret i1 %x
 }
@@ -149,21 +167,27 @@
 
 define float @constant_fold_bitcast_ftoi_load() {
 ; CHECK-LABEL: @constant_fold_bitcast_ftoi_load(
-; CHECK: load float, float addrspace(3)* bitcast (i32 addrspace(3)* @g to float addrspace(3)*), align 4
+; CHECK-NEXT:    [[A:%.*]] = load float, float addrspace(3)* bitcast (i32 addrspace(3)* @g to float addrspace(3)*), align 4
+; CHECK-NEXT:    ret float [[A]]
+;
   %a = load float, float addrspace(3)* bitcast (i32 addrspace(3)* @g to float addrspace(3)*), align 4
   ret float %a
 }
 
 define i32 @constant_fold_bitcast_itof_load() {
 ; CHECK-LABEL: @constant_fold_bitcast_itof_load(
-; CHECK: load i32, i32 addrspace(3)* bitcast (float addrspace(3)* @g_float_as3 to i32 addrspace(3)*), align 4
+; CHECK-NEXT:    [[A:%.*]] = load i32, i32 addrspace(3)* bitcast (float addrspace(3)* @g_float_as3 to i32 addrspace(3)*), align 4
+; CHECK-NEXT:    ret i32 [[A]]
+;
   %a = load i32, i32 addrspace(3)* bitcast (float addrspace(3)* @g_float_as3 to i32 addrspace(3)*), align 4
   ret i32 %a
 }
 
 define <4 x float> @constant_fold_bitcast_vector_as() {
 ; CHECK-LABEL: @constant_fold_bitcast_vector_as(
-; CHECK: load <4 x float>, <4 x float> addrspace(3)* @g_v4f_as3, align 16
+; CHECK-NEXT:    [[A:%.*]] = load <4 x float>, <4 x float> addrspace(3)* @g_v4f_as3, align 16
+; CHECK-NEXT:    ret <4 x float> [[A]]
+;
   %a = load <4 x float>, <4 x float> addrspace(3)* bitcast (<4 x i32> addrspace(3)* bitcast (<4 x float> addrspace(3)* @g_v4f_as3 to <4 x i32> addrspace(3)*) to <4 x float> addrspace(3)*), align 4
   ret <4 x float> %a
 }
@@ -172,10 +196,12 @@
 
 define i32 @test_cast_gep_small_indices_as() {
 ; CHECK-LABEL: @test_cast_gep_small_indices_as(
-; CHECK: load i32, i32 addrspace(3)* getelementptr inbounds ([10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i16 0, i16 0), align 16
-   %p = getelementptr [10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i7 0, i7 0
-   %x = load i32, i32 addrspace(3)* %p, align 4
-   ret i32 %x
+; CHECK-NEXT:    [[X:%.*]] = load i32, i32 addrspace(3)* getelementptr inbounds ([10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i16 0, i16 0), align 16
+; CHECK-NEXT:    ret i32 [[X]]
+;
+  %p = getelementptr [10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i7 0, i7 0
+  %x = load i32, i32 addrspace(3)* %p, align 4
+  ret i32 %x
 }
 
 %struct.foo = type { float, float, [4 x i32], i32 addrspace(3)* }
@@ -189,15 +215,19 @@
 
 define i32 @test_cast_gep_large_indices_as() {
 ; CHECK-LABEL: @test_cast_gep_large_indices_as(
-; CHECK: load i32, i32 addrspace(3)* getelementptr inbounds ([10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i16 0, i16 0), align 16
-   %p = getelementptr [10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i64 0, i64 0
-   %x = load i32, i32 addrspace(3)* %p, align 4
-   ret i32 %x
+; CHECK-NEXT:    [[X:%.*]] = load i32, i32 addrspace(3)* getelementptr inbounds ([10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i16 0, i16 0), align 16
+; CHECK-NEXT:    ret i32 [[X]]
+;
+  %p = getelementptr [10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i64 0, i64 0
+  %x = load i32, i32 addrspace(3)* %p, align 4
+  ret i32 %x
 }
 
 define i32 @test_constant_cast_gep_struct_indices_as() {
 ; CHECK-LABEL: @test_constant_cast_gep_struct_indices_as(
-; CHECK: load i32, i32 addrspace(3)* getelementptr inbounds (%struct.foo, %struct.foo addrspace(3)* @constant_fold_global_ptr, i16 0, i32 2, i16 2), align 8
+; CHECK-NEXT:    [[Y:%.*]] = load i32, i32 addrspace(3)* getelementptr inbounds (%struct.foo, [[STRUCT_FOO:%.*]] addrspace(3)* @constant_fold_global_ptr, i16 0, i32 2, i16 2), align 16
+; CHECK-NEXT:    ret i32 [[Y]]
+;
   %x = getelementptr %struct.foo, %struct.foo addrspace(3)* @constant_fold_global_ptr, i18 0, i32 2, i12 2
   %y = load i32, i32 addrspace(3)* %x, align 4
   ret i32 %y
@@ -207,7 +237,8 @@
 
 define i32 @test_read_data_from_global_as3() {
 ; CHECK-LABEL: @test_read_data_from_global_as3(
-; CHECK-NEXT: ret i32 2
+; CHECK-NEXT:    ret i32 2
+;
   %x = getelementptr [5 x i32], [5 x i32] addrspace(3)* @constant_data_as3, i32 0, i32 1
   %y = load i32, i32 addrspace(3)* %x, align 4
   ret i32 %y
@@ -223,7 +254,8 @@
 
 define i32 @constant_through_array_as_ptrs() {
 ; CHECK-LABEL: @constant_through_array_as_ptrs(
-; CHECK-NEXT: ret i32 34
+; CHECK-NEXT:    ret i32 34
+;
   %p = load i32 addrspace(1)* addrspace(2)*, i32 addrspace(1)* addrspace(2)* addrspace(0)* @indirect, align 4
   %a = load i32 addrspace(1)*, i32 addrspace(1)* addrspace(2)* %p, align 4
   %b = load i32, i32 addrspace(1)* %a, align 4
@@ -233,8 +265,11 @@
 @shared_mem = external addrspace(3) global [0 x i8]
 
 define float @canonicalize_addrspacecast(i32 %i) {
-; CHECK-LABEL: @canonicalize_addrspacecast
-; CHECK-NEXT: getelementptr inbounds float, float* addrspacecast (float addrspace(3)* bitcast ([0 x i8] addrspace(3)* @shared_mem to float addrspace(3)*) to float*), i32 %i
+; CHECK-LABEL: @canonicalize_addrspacecast(
+; CHECK-NEXT:    [[P:%.*]] = getelementptr inbounds float, float* addrspacecast (float addrspace(3)* bitcast ([0 x i8] addrspace(3)* @shared_mem to float addrspace(3)*) to float*), i32 [[I:%.*]]
+; CHECK-NEXT:    [[V:%.*]] = load float, float* [[P]], align 4
+; CHECK-NEXT:    ret float [[V]]
+;
   %p = getelementptr inbounds float, float* addrspacecast ([0 x i8] addrspace(3)* @shared_mem to float*), i32 %i
   %v = load float, float* %p
   ret float %v
diff --git a/llvm/test/Transforms/InstCombine/constant-fold-alias.ll b/llvm/test/Transforms/InstCombine/constant-fold-alias.ll
--- a/llvm/test/Transforms/InstCombine/constant-fold-alias.ll
+++ b/llvm/test/Transforms/InstCombine/constant-fold-alias.ll
@@ -1,3 +1,4 @@
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -S < %s -instcombine | FileCheck %s
 
 target datalayout = "e-p1:16:16-p2:32:32-p3:64:64"
@@ -12,21 +13,24 @@
 define i64 @f1() {
 ; This cannot be constant folded because G1 is underaligned.
 ; CHECK-LABEL: @f1(
-; CHECK: ret i64 and
+; CHECK-NEXT:    ret i64 and (i64 ptrtoint (i32* @G1 to i64), i64 1)
+;
   ret i64 and (i64 ptrtoint (i32* @G1 to i64), i64 1)
 }
 
 define i64 @f2() {
 ; The preferred alignment for G2 allows this one to foled to zero.
 ; CHECK-LABEL: @f2(
-; CHECK: ret i64 0
+; CHECK-NEXT:    ret i64 0
+;
   ret i64 and (i64 ptrtoint (i32* @G2 to i64), i64 1)
 }
 
 define i64 @g1() {
 ; This cannot be constant folded because A1 aliases G3 which is underalaigned.
 ; CHECK-LABEL: @g1(
-; CHECK: ret i64 and
+; CHECK-NEXT:    ret i64 and (i64 ptrtoint (i32* @A1 to i64), i64 1)
+;
   ret i64 and (i64 ptrtoint (i32* @A1 to i64), i64 1)
 }
 
@@ -34,7 +38,8 @@
 ; While A2 also aliases G3 which is underaligned, the math of A2 forces a
 ; certain alignment allowing this to fold to zero.
 ; CHECK-LABEL: @g2(
-; CHECK: ret i64 0
+; CHECK-NEXT:    ret i64 0
+;
   ret i64 and (i64 ptrtoint (i32* @A2 to i64), i64 1)
 }
 
diff --git a/llvm/test/Transforms/InstCombine/constant-fold-gep.ll b/llvm/test/Transforms/InstCombine/constant-fold-gep.ll
--- a/llvm/test/Transforms/InstCombine/constant-fold-gep.ll
+++ b/llvm/test/Transforms/InstCombine/constant-fold-gep.ll
@@ -17,7 +17,7 @@
   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
@@ -25,11 +25,11 @@
   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
@@ -41,7 +41,7 @@
   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
diff --git a/llvm/test/Transforms/InstCombine/gep-addrspace.ll b/llvm/test/Transforms/InstCombine/gep-addrspace.ll
--- a/llvm/test/Transforms/InstCombine/gep-addrspace.ll
+++ b/llvm/test/Transforms/InstCombine/gep-addrspace.ll
@@ -29,8 +29,8 @@
 ; CHECK-NEXT:    [[T0:%.*]] = addrspacecast float addrspace(3)* [[T01]] to float*
 ; CHECK-NEXT:    [[TMP1:%.*]] = getelementptr float, float addrspace(3)* @scalar, i64 [[I]]
 ; CHECK-NEXT:    [[T1:%.*]] = addrspacecast float addrspace(3)* [[TMP1]] to float*
-; CHECK-NEXT:    store float* [[T0]], float** [[OUT0:%.*]], align 4
-; CHECK-NEXT:    store float* [[T1]], float** [[OUT1:%.*]], align 4
+; CHECK-NEXT:    store float* [[T0]], float** [[OUT0:%.*]], align 8
+; CHECK-NEXT:    store float* [[T1]], float** [[OUT1:%.*]], align 8
 ; CHECK-NEXT:    ret void
 ;
   %t0 = getelementptr [256 x float], [256 x float]* addrspacecast ([256 x float] addrspace(3)* @array to [256 x float]*), i64 0, i64 %i
diff --git a/llvm/test/Transforms/InstCombine/load-bitcast-vec.ll b/llvm/test/Transforms/InstCombine/load-bitcast-vec.ll
--- a/llvm/test/Transforms/InstCombine/load-bitcast-vec.ll
+++ b/llvm/test/Transforms/InstCombine/load-bitcast-vec.ll
@@ -48,7 +48,7 @@
 define i8 @smaller_scalar_less_aligned(<4 x float>* dereferenceable(16) %p) {
 ; CHECK-LABEL: @smaller_scalar_less_aligned(
 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <4 x float>* [[P:%.*]] to i8*
-; CHECK-NEXT:    [[R:%.*]] = load i8, i8* [[BC]], align 4
+; CHECK-NEXT:    [[R:%.*]] = load i8, i8* [[BC]], align 16
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
   %bc = bitcast <4 x float>* %p to i8*
diff --git a/llvm/test/Transforms/InstCombine/masked_intrinsics.ll b/llvm/test/Transforms/InstCombine/masked_intrinsics.ll
--- a/llvm/test/Transforms/InstCombine/masked_intrinsics.ll
+++ b/llvm/test/Transforms/InstCombine/masked_intrinsics.ll
@@ -17,7 +17,7 @@
 
 define <2 x double> @load_onemask(<2 x double>* %ptr, <2 x double> %passthru)  {
 ; CHECK-LABEL: @load_onemask(
-; CHECK-NEXT:    [[UNMASKEDLOAD:%.*]] = load <2 x double>, <2 x double>* [[PTR:%.*]], align 2
+; CHECK-NEXT:    [[UNMASKEDLOAD:%.*]] = load <2 x double>, <2 x double>* [[PTR:%.*]], align 16
 ; CHECK-NEXT:    ret <2 x double> [[UNMASKEDLOAD]]
 ;
   %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %ptr, i32 2, <2 x i1> <i1 1, i1 1>, <2 x double> %passthru)
@@ -26,7 +26,7 @@
 
 define <2 x double> @load_undefmask(<2 x double>* %ptr, <2 x double> %passthru)  {
 ; CHECK-LABEL: @load_undefmask(
-; CHECK-NEXT:    [[UNMASKEDLOAD:%.*]] = load <2 x double>, <2 x double>* [[PTR:%.*]], align 2
+; CHECK-NEXT:    [[UNMASKEDLOAD:%.*]] = load <2 x double>, <2 x double>* [[PTR:%.*]], align 16
 ; CHECK-NEXT:    ret <2 x double> [[UNMASKEDLOAD]]
 ;
   %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %ptr, i32 2, <2 x i1> <i1 1, i1 undef>, <2 x double> %passthru)
@@ -87,7 +87,7 @@
 ; 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:    [[UNMASKEDLOAD:%.*]] = load <2 x double>, <2 x double>* [[PTR:%.*]], align 16
 ; CHECK-NEXT:    [[TMP1:%.*]] = select <2 x i1> [[MASK:%.*]], <2 x double> [[UNMASKEDLOAD]], <2 x double> [[PTV2]]
 ; CHECK-NEXT:    ret <2 x double> [[TMP1]]
 ;
@@ -154,7 +154,7 @@
 
 define void @store_onemask(<2 x double>* %ptr, <2 x double> %val)  {
 ; CHECK-LABEL: @store_onemask(
-; CHECK-NEXT:    store <2 x double> [[VAL:%.*]], <2 x double>* [[PTR:%.*]], align 4
+; CHECK-NEXT:    store <2 x double> [[VAL:%.*]], <2 x double>* [[PTR:%.*]], align 16
 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.masked.store.v2f64.p0v2f64(<2 x double> %val, <2 x double>* %ptr, i32 4, <2 x i1> <i1 1, i1 1>)
diff --git a/llvm/test/Transforms/InstCombine/memcpy-from-global.ll b/llvm/test/Transforms/InstCombine/memcpy-from-global.ll
--- a/llvm/test/Transforms/InstCombine/memcpy-from-global.ll
+++ b/llvm/test/Transforms/InstCombine/memcpy-from-global.ll
@@ -125,7 +125,7 @@
 ; CHECK-NEXT:    [[B1:%.*]] = alloca [124 x i8], align 8
 ; CHECK-NEXT:    [[B1_SUB:%.*]] = getelementptr inbounds [124 x i8], [124 x i8]* [[B1]], i64 0, i64 0
 ; CHECK-NEXT:    [[B:%.*]] = addrspacecast i8* [[B1_SUB]] to i8 addrspace(1)*
-; CHECK-NEXT:    call void @llvm.memcpy.p1i8.p1i8.i64(i8 addrspace(1)* align 4 dereferenceable(124) [[B]], i8 addrspace(1)* align 4 dereferenceable(124) addrspacecast (i8* getelementptr inbounds (%T, %T* @G, i64 0, i32 0) to i8 addrspace(1)*), i64 124, i1 false)
+; CHECK-NEXT:    call void @llvm.memcpy.p1i8.p1i8.i64(i8 addrspace(1)* align 8 dereferenceable(124) [[B]], i8 addrspace(1)* align 4 dereferenceable(124) addrspacecast (i8* getelementptr inbounds (%T, %T* @G, i64 0, i32 0) to i8 addrspace(1)*), i64 124, i1 false)
 ; CHECK-NEXT:    call void @bar_as1(i8 addrspace(1)* [[B]])
 ; CHECK-NEXT:    ret void
 ;
diff --git a/llvm/test/Transforms/InstCombine/phi.ll b/llvm/test/Transforms/InstCombine/phi.ll
--- a/llvm/test/Transforms/InstCombine/phi.ll
+++ b/llvm/test/Transforms/InstCombine/phi.ll
@@ -162,7 +162,7 @@
 ; CHECK-LABEL: @test9(
 ; CHECK:       bb2:
 ; CHECK-NEXT:        phi i32* [ %B, %bb ], [ %A, %bb1 ]
-; CHECK-NEXT:   %E = load i32, i32* %{{[^,]*}}, align 1
+; CHECK-NEXT:   %E = load i32, i32* %{{[^,]*}}, align 4
 ; CHECK-NEXT:   ret i32 %E
 
 }
diff --git a/llvm/test/Transforms/InstCombine/ptr-int-cast.ll b/llvm/test/Transforms/InstCombine/ptr-int-cast.ll
--- a/llvm/test/Transforms/InstCombine/ptr-int-cast.ll
+++ b/llvm/test/Transforms/InstCombine/ptr-int-cast.ll
@@ -4,7 +4,7 @@
 define i1 @test1(i32 *%x) nounwind {
 entry:
 ; CHECK: test1
-; CHECK: ptrtoint i32* %x to i64
+; CHECK: ret i1 false
 	%0 = ptrtoint i32* %x to i1
 	ret i1 %0
 }
diff --git a/llvm/test/Transforms/InstCombine/rem.ll b/llvm/test/Transforms/InstCombine/rem.ll
--- a/llvm/test/Transforms/InstCombine/rem.ll
+++ b/llvm/test/Transforms/InstCombine/rem.ll
@@ -718,7 +718,7 @@
 define i1 @test27(i32 %A, i32* %remdst) {
 ; CHECK-LABEL: @test27(
 ; CHECK-NEXT:    [[B:%.*]] = srem i32 [[A:%.*]], -2147483648
-; CHECK-NEXT:    store i32 [[B]], i32* [[REMDST:%.*]], align 1
+; CHECK-NEXT:    store i32 [[B]], i32* [[REMDST:%.*]], align 4
 ; CHECK-NEXT:    [[C:%.*]] = icmp ne i32 [[B]], 0
 ; CHECK-NEXT:    ret i1 [[C]]
 ;
diff --git a/llvm/test/Transforms/InstCombine/scalarization.ll b/llvm/test/Transforms/InstCombine/scalarization.ll
--- a/llvm/test/Transforms/InstCombine/scalarization.ll
+++ b/llvm/test/Transforms/InstCombine/scalarization.ll
@@ -3,7 +3,7 @@
 
 define i32 @extract_load(<4 x i32>* %p) {
 ; CHECK-LABEL: @extract_load(
-; CHECK-NEXT:    [[X:%.*]] = load <4 x i32>, <4 x i32>* [[P:%.*]], align 4
+; CHECK-NEXT:    [[X:%.*]] = load <4 x i32>, <4 x i32>* [[P:%.*]], align 16
 ; CHECK-NEXT:    [[EXT:%.*]] = extractelement <4 x i32> [[X]], i32 1
 ; CHECK-NEXT:    ret i32 [[EXT]]
 ;
@@ -36,7 +36,7 @@
 
 define double @extract_load_extra_use(<4 x double>* %p, <4 x double>* %p2) {
 ; CHECK-LABEL: @extract_load_extra_use(
-; CHECK-NEXT:    [[X:%.*]] = load <4 x double>, <4 x double>* [[P:%.*]], align 8
+; CHECK-NEXT:    [[X:%.*]] = load <4 x double>, <4 x double>* [[P:%.*]], align 32
 ; CHECK-NEXT:    [[EXT:%.*]] = extractelement <4 x double> [[X]], i32 0
 ; CHECK-NEXT:    store <4 x double> [[X]], <4 x double>* [[P2:%.*]], align 32
 ; CHECK-NEXT:    ret double [[EXT]]
diff --git a/llvm/test/Transforms/InstCombine/store.ll b/llvm/test/Transforms/InstCombine/store.ll
--- a/llvm/test/Transforms/InstCombine/store.ll
+++ b/llvm/test/Transforms/InstCombine/store.ll
@@ -108,7 +108,7 @@
 ; CHECK-NEXT:    br label [[CONT]]
 ; CHECK:       Cont:
 ; CHECK-NEXT:    [[STOREMERGE:%.*]] = phi i32 [ -987654321, [[COND]] ], [ 47, [[TMP0:%.*]] ]
-; CHECK-NEXT:    store i32 [[STOREMERGE]], i32* [[P:%.*]], align 1
+; CHECK-NEXT:    store i32 [[STOREMERGE]], i32* [[P:%.*]], align 4
 ; CHECK-NEXT:    ret void
 ;
   store i32 47, i32* %P, align 1
diff --git a/llvm/test/Transforms/InstCombine/trunc-load.ll b/llvm/test/Transforms/InstCombine/trunc-load.ll
--- a/llvm/test/Transforms/InstCombine/trunc-load.ll
+++ b/llvm/test/Transforms/InstCombine/trunc-load.ll
@@ -58,7 +58,7 @@
 
 define i32 @truncload_extra_use(i64* dereferenceable(100) %ptr) {
 ; CHECK-LABEL: @truncload_extra_use(
-; CHECK-NEXT:    [[X:%.*]] = load i64, i64* [[PTR:%.*]], align 2
+; CHECK-NEXT:    [[X:%.*]] = load i64, i64* [[PTR:%.*]], align 4
 ; CHECK-NEXT:    call void @use(i64 [[X]])
 ; CHECK-NEXT:    [[R:%.*]] = trunc i64 [[X]] to i32
 ; CHECK-NEXT:    ret i32 [[R]]
@@ -73,7 +73,7 @@
 
 define i8 @truncload_type(i64* dereferenceable(9) %ptr) {
 ; CHECK-LABEL: @truncload_type(
-; CHECK-NEXT:    [[X:%.*]] = load i64, i64* [[PTR:%.*]], align 2
+; CHECK-NEXT:    [[X:%.*]] = load i64, i64* [[PTR:%.*]], align 4
 ; CHECK-NEXT:    [[R:%.*]] = trunc i64 [[X]] to i8
 ; CHECK-NEXT:    ret i8 [[R]]
 ;
diff --git a/llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/merge-stores-private.ll b/llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/merge-stores-private.ll
--- a/llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/merge-stores-private.ll
+++ b/llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/merge-stores-private.ll
@@ -44,7 +44,7 @@
 ; ELT4-UNALIGNED: store i32
 ; ELT4-UNALIGNED: store i32
 ; ELT4-UNALIGNED: store i32
-define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v4i32_align1(i32 addrspace(5)* %out) #0 {
+define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v4i32_align1(i32 addrspace(5)* align 1 %out) #0 {
   %out.gep.1 = getelementptr i32, i32 addrspace(5)* %out, i32 1
   %out.gep.2 = getelementptr i32, i32 addrspace(5)* %out, i32 2
   %out.gep.3 = getelementptr i32, i32 addrspace(5)* %out, i32 3
@@ -71,7 +71,7 @@
 ; ELT4-UNALIGNED: store i32
 ; ELT4-UNALIGNED: store i32
 ; ELT4-UNALIGNED: store i32
-define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v4i32_align2(i32 addrspace(5)* %out) #0 {
+define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v4i32_align2(i32 addrspace(5)* align 2 %out) #0 {
   %out.gep.1 = getelementptr i32, i32 addrspace(5)* %out, i32 1
   %out.gep.2 = getelementptr i32, i32 addrspace(5)* %out, i32 2
   %out.gep.3 = getelementptr i32, i32 addrspace(5)* %out, i32 3
@@ -104,7 +104,7 @@
 ; ALIGNED: store i8
 
 ; UNALIGNED: store <4 x i8> <i8 9, i8 1, i8 23, i8 19>, <4 x i8> addrspace(5)* %1, align 1
-define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v4i8_align1(i8 addrspace(5)* %out) #0 {
+define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v4i8_align1(i8 addrspace(5)* align 1 %out) #0 {
   %out.gep.1 = getelementptr i8, i8 addrspace(5)* %out, i32 1
   %out.gep.2 = getelementptr i8, i8 addrspace(5)* %out, i32 2
   %out.gep.3 = getelementptr i8, i8 addrspace(5)* %out, i32 3
@@ -131,7 +131,7 @@
 ; ALIGNED: store i16
 
 ; UNALIGNED: store <2 x i16> <i16 9, i16 12>, <2 x i16> addrspace(5)* %1, align 2
-define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v2i16_align2(i16 addrspace(5)* %out) #0 {
+define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v2i16_align2(i16 addrspace(5)* align 2 %out) #0 {
   %out.gep.1 = getelementptr i16, i16 addrspace(5)* %out, i32 1
 
   store i16 9, i16 addrspace(5)* %out, align 2
@@ -194,7 +194,7 @@
 ; ELT8-UNALIGNED: store i32
 
 ; ELT16-UNALIGNED: store <3 x i32>
-define amdgpu_kernel void @merge_private_store_3_vector_elts_loads_v4i32_align1(i32 addrspace(5)* %out) #0 {
+define amdgpu_kernel void @merge_private_store_3_vector_elts_loads_v4i32_align1(i32 addrspace(5)* align 1 %out) #0 {
   %out.gep.1 = getelementptr i32, i32 addrspace(5)* %out, i32 1
   %out.gep.2 = getelementptr i32, i32 addrspace(5)* %out, i32 2
 
@@ -210,7 +210,7 @@
 ; ALIGNED: store i8
 
 ; UNALIGNED: store <3 x i8>
-define amdgpu_kernel void @merge_private_store_3_vector_elts_loads_v4i8_align1(i8 addrspace(5)* %out) #0 {
+define amdgpu_kernel void @merge_private_store_3_vector_elts_loads_v4i8_align1(i8 addrspace(5)* align 1 %out) #0 {
   %out.gep.1 = getelementptr i8, i8 addrspace(5)* %out, i8 1
   %out.gep.2 = getelementptr i8, i8 addrspace(5)* %out, i8 2
 
diff --git a/llvm/test/Transforms/LoopVectorize/AArch64/aarch64-predication.ll b/llvm/test/Transforms/LoopVectorize/AArch64/aarch64-predication.ll
--- a/llvm/test/Transforms/LoopVectorize/AArch64/aarch64-predication.ll
+++ b/llvm/test/Transforms/LoopVectorize/AArch64/aarch64-predication.ll
@@ -20,7 +20,7 @@
 ; CHECK-NEXT:    [[VEC_PHI:%.*]] = phi <2 x i64> [ zeroinitializer, %entry ], [ [[TMP17:%.*]], %[[PRED_UDIV_CONTINUE2]] ]
 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds i64, i64* %a, i64 [[INDEX]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast i64* [[TMP0]] to <2 x i64>*
-; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i64>, <2 x i64>* [[TMP1]], align 4
+; CHECK-NEXT:    [[WIDE_LOAD:%.*]] = load <2 x i64>, <2 x i64>* [[TMP1]], align 8
 ; CHECK-NEXT:    [[TMP2:%.*]] = icmp sgt <2 x i64> [[WIDE_LOAD]], zeroinitializer
 ; CHECK-NEXT:    [[TMP3:%.*]] = extractelement <2 x i1> [[TMP2]], i32 0
 ; CHECK-NEXT:    br i1 [[TMP3]], label %[[PRED_UDIV_IF:.*]], label %[[PRED_UDIV_CONTINUE:.*]]
diff --git a/llvm/test/Transforms/LoopVectorize/X86/consecutive-ptr-uniforms.ll b/llvm/test/Transforms/LoopVectorize/X86/consecutive-ptr-uniforms.ll
--- a/llvm/test/Transforms/LoopVectorize/X86/consecutive-ptr-uniforms.ll
+++ b/llvm/test/Transforms/LoopVectorize/X86/consecutive-ptr-uniforms.ll
@@ -33,7 +33,7 @@
 ; CHECK-NEXT:    [[TMP3:%.*]] = getelementptr inbounds %data, %data* %d, i64 0, i32 0, <16 x i64> [[VEC_IND]]
 ; CHECK-NEXT:    [[BC:%.*]] = bitcast <16 x float*> [[TMP3]] to <16 x <80 x float>*>
 ; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <16 x <80 x float>*> [[BC]], i32 0
-; CHECK-NEXT:    [[WIDE_VEC1:%.*]] = load <80 x float>, <80 x float>* [[TMP4]], align 4
+; CHECK-NEXT:    [[WIDE_VEC1:%.*]] = load <80 x float>, <80 x float>* [[TMP4]], align 512
 ; CHECK-NEXT:    [[STRIDED_VEC2:%.*]] = shufflevector <80 x float> [[WIDE_VEC1]], <80 x float> undef, <16 x i32> <i32 0, i32 5, i32 10, i32 15, i32 20, i32 25, i32 30, i32 35, i32 40, i32 45, i32 50, i32 55, i32 60, i32 65, i32 70, i32 75>
 ; CHECK-NEXT:    [[TMP5:%.*]] = fadd <16 x float> [[STRIDED_VEC2]], [[TMP2]]
 ; CHECK-NEXT:    call void @llvm.masked.scatter.v16f32.v16p0f32(<16 x float> [[TMP5]], <16 x float*> [[TMP3]], i32 4, <16 x i1> <i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true, i1 true>)
diff --git a/llvm/test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll b/llvm/test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll
--- a/llvm/test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll
+++ b/llvm/test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll
@@ -457,7 +457,7 @@
 ; INTER-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %vector.ph ], [ [[INDEX_NEXT:%.*]], %vector.body ]
 ; INTER-NEXT:    [[TMP4:%.*]] = getelementptr inbounds i64, i64* %A, i64 [[INDEX]]
 ; INTER-NEXT:    [[TMP5:%.*]] = bitcast i64* [[TMP4]] to <32 x i8>*
-; INTER-NEXT:    [[WIDE_VEC:%.*]] = load <32 x i8>, <32 x i8>* [[TMP5]], align 1
+; INTER-NEXT:    [[WIDE_VEC:%.*]] = load <32 x i8>, <32 x i8>* [[TMP5]], align 8
 ; INTER-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <32 x i8> [[WIDE_VEC]], <32 x i8> undef, <4 x i32> <i32 0, i32 8, i32 16, i32 24>
 ; INTER-NEXT:    [[STRIDED_VEC5:%.*]] = shufflevector <32 x i8> [[WIDE_VEC]], <32 x i8> undef, <4 x i32> <i32 3, i32 11, i32 19, i32 27>
 ; INTER-NEXT:    [[TMP6:%.*]] = xor <4 x i8> [[STRIDED_VEC5]], [[STRIDED_VEC]]
diff --git a/llvm/test/Transforms/SLPVectorizer/AArch64/getelementptr.ll b/llvm/test/Transforms/SLPVectorizer/AArch64/getelementptr.ll
--- a/llvm/test/Transforms/SLPVectorizer/AArch64/getelementptr.ll
+++ b/llvm/test/Transforms/SLPVectorizer/AArch64/getelementptr.ll
@@ -69,23 +69,23 @@
 ; CHECK-NEXT:    [[TMP9:%.*]] = extractelement <4 x i32> [[TMP8]], i32 0
 ; CHECK-NEXT:    [[TMP10:%.*]] = sext i32 [[TMP9]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[G:%.*]], i64 [[TMP10]]
-; CHECK-NEXT:    [[T6:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    [[T6:%.*]] = load i32, i32* [[ARRAYIDX]], align 8
 ; CHECK-NEXT:    [[TMP11:%.*]] = extractelement <2 x i32> [[TMP4]], i32 1
 ; CHECK-NEXT:    [[ADD1:%.*]] = add nsw i32 [[T6]], [[TMP11]]
 ; CHECK-NEXT:    [[TMP12:%.*]] = extractelement <4 x i32> [[TMP8]], i32 1
 ; CHECK-NEXT:    [[TMP13:%.*]] = sext i32 [[TMP12]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX5:%.*]] = getelementptr inbounds i32, i32* [[G]], i64 [[TMP13]]
-; CHECK-NEXT:    [[T8:%.*]] = load i32, i32* [[ARRAYIDX5]], align 4
+; CHECK-NEXT:    [[T8:%.*]] = load i32, i32* [[ARRAYIDX5]], align 8
 ; CHECK-NEXT:    [[ADD6:%.*]] = add nsw i32 [[ADD1]], [[T8]]
 ; CHECK-NEXT:    [[TMP14:%.*]] = extractelement <4 x i32> [[TMP8]], i32 2
 ; CHECK-NEXT:    [[TMP15:%.*]] = sext i32 [[TMP14]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX10:%.*]] = getelementptr inbounds i32, i32* [[G]], i64 [[TMP15]]
-; CHECK-NEXT:    [[T10:%.*]] = load i32, i32* [[ARRAYIDX10]], align 4
+; CHECK-NEXT:    [[T10:%.*]] = load i32, i32* [[ARRAYIDX10]], align 8
 ; CHECK-NEXT:    [[ADD11:%.*]] = add nsw i32 [[ADD6]], [[T10]]
 ; CHECK-NEXT:    [[TMP16:%.*]] = extractelement <4 x i32> [[TMP8]], i32 3
 ; CHECK-NEXT:    [[TMP17:%.*]] = sext i32 [[TMP16]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX15:%.*]] = getelementptr inbounds i32, i32* [[G]], i64 [[TMP17]]
-; CHECK-NEXT:    [[T12:%.*]] = load i32, i32* [[ARRAYIDX15]], align 4
+; CHECK-NEXT:    [[T12:%.*]] = load i32, i32* [[ARRAYIDX15]], align 8
 ; CHECK-NEXT:    [[TMP18:%.*]] = insertelement <2 x i32> undef, i32 [[TMP5]], i32 0
 ; CHECK-NEXT:    [[TMP19:%.*]] = insertelement <2 x i32> [[TMP18]], i32 [[ADD11]], i32 1
 ; CHECK-NEXT:    [[TMP20:%.*]] = insertelement <2 x i32> <i32 1, i32 undef>, i32 [[T12]], i32 1
@@ -174,13 +174,13 @@
 ; CHECK-NEXT:    [[T4:%.*]] = shl nsw i32 [[TMP4]], 1
 ; CHECK-NEXT:    [[TMP5:%.*]] = sext i32 [[T4]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX:%.*]] = getelementptr inbounds i32, i32* [[G:%.*]], i64 [[TMP5]]
-; CHECK-NEXT:    [[T6:%.*]] = load i32, i32* [[ARRAYIDX]], align 4
+; CHECK-NEXT:    [[T6:%.*]] = load i32, i32* [[ARRAYIDX]], align 8
 ; CHECK-NEXT:    [[TMP6:%.*]] = extractelement <2 x i32> [[TMP3]], i32 1
 ; CHECK-NEXT:    [[ADD1:%.*]] = add nsw i32 [[T6]], [[TMP6]]
 ; CHECK-NEXT:    [[T7:%.*]] = or i32 [[T4]], 1
 ; CHECK-NEXT:    [[TMP7:%.*]] = sext i32 [[T7]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX5:%.*]] = getelementptr inbounds i32, i32* [[G]], i64 [[TMP7]]
-; CHECK-NEXT:    [[T8:%.*]] = load i32, i32* [[ARRAYIDX5]], align 4
+; CHECK-NEXT:    [[T8:%.*]] = load i32, i32* [[ARRAYIDX5]], align 8
 ; CHECK-NEXT:    [[ADD6:%.*]] = add nsw i32 [[ADD1]], [[T8]]
 ; CHECK-NEXT:    [[TMP8:%.*]] = insertelement <2 x i32> undef, i32 [[T4]], i32 0
 ; CHECK-NEXT:    [[TMP9:%.*]] = shufflevector <2 x i32> [[TMP8]], <2 x i32> undef, <2 x i32> zeroinitializer
@@ -188,12 +188,12 @@
 ; CHECK-NEXT:    [[TMP11:%.*]] = extractelement <2 x i32> [[TMP10]], i32 0
 ; CHECK-NEXT:    [[TMP12:%.*]] = sext i32 [[TMP11]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX10:%.*]] = getelementptr inbounds i32, i32* [[G]], i64 [[TMP12]]
-; CHECK-NEXT:    [[T10:%.*]] = load i32, i32* [[ARRAYIDX10]], align 4
+; CHECK-NEXT:    [[T10:%.*]] = load i32, i32* [[ARRAYIDX10]], align 8
 ; CHECK-NEXT:    [[ADD11:%.*]] = add nsw i32 [[ADD6]], [[T10]]
 ; CHECK-NEXT:    [[TMP13:%.*]] = extractelement <2 x i32> [[TMP10]], i32 1
 ; CHECK-NEXT:    [[TMP14:%.*]] = sext i32 [[TMP13]] to i64
 ; CHECK-NEXT:    [[ARRAYIDX15:%.*]] = getelementptr inbounds i32, i32* [[G]], i64 [[TMP14]]
-; CHECK-NEXT:    [[T12:%.*]] = load i32, i32* [[ARRAYIDX15]], align 4
+; CHECK-NEXT:    [[T12:%.*]] = load i32, i32* [[ARRAYIDX15]], align 8
 ; CHECK-NEXT:    [[TMP15:%.*]] = insertelement <2 x i32> undef, i32 [[TMP4]], i32 0
 ; CHECK-NEXT:    [[TMP16:%.*]] = insertelement <2 x i32> [[TMP15]], i32 [[ADD11]], i32 1
 ; CHECK-NEXT:    [[TMP17:%.*]] = insertelement <2 x i32> <i32 1, i32 undef>, i32 [[T12]], i32 1
diff --git a/llvm/test/Transforms/SimplifyCFG/switch_create-custom-dl.ll b/llvm/test/Transforms/SimplifyCFG/switch_create-custom-dl.ll
--- a/llvm/test/Transforms/SimplifyCFG/switch_create-custom-dl.ll
+++ b/llvm/test/Transforms/SimplifyCFG/switch_create-custom-dl.ll
@@ -34,10 +34,8 @@
 define void @test1_ptr(i32* %V) {
 ; CHECK-LABEL: @test1_ptr(
 ; CHECK-NEXT:    [[MAGICPTR:%.*]] = ptrtoint i32* [[V:%.*]] to i32
-; CHECK-NEXT:    switch i32 [[MAGICPTR]], label [[F:%.*]] [
-; CHECK-NEXT:    i32 17, label [[T:%.*]]
-; CHECK-NEXT:    i32 4, label [[T]]
-; CHECK-NEXT:    ]
+; CHECK-NEXT:    [[COND:%.*]] = icmp eq i32 [[MAGICPTR]], 4
+; CHECK-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       T:
 ; CHECK-NEXT:    call void @foo1()
 ; CHECK-NEXT:    ret void
@@ -60,10 +58,8 @@
 define void @test1_ptr_as1(i32 addrspace(1)* %V) {
 ; CHECK-LABEL: @test1_ptr_as1(
 ; CHECK-NEXT:    [[MAGICPTR:%.*]] = ptrtoint i32 addrspace(1)* [[V:%.*]] to i32
-; CHECK-NEXT:    switch i32 [[MAGICPTR]], label [[F:%.*]] [
-; CHECK-NEXT:    i32 17, label [[T:%.*]]
-; CHECK-NEXT:    i32 4, label [[T]]
-; CHECK-NEXT:    ]
+; CHECK-NEXT:    [[COND:%.*]] = icmp eq i32 [[MAGICPTR]], 4
+; CHECK-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
 ; CHECK:       T:
 ; CHECK-NEXT:    call void @foo1()
 ; CHECK-NEXT:    ret void
diff --git a/llvm/test/Transforms/SimplifyCFG/switch_create.ll b/llvm/test/Transforms/SimplifyCFG/switch_create.ll
--- a/llvm/test/Transforms/SimplifyCFG/switch_create.ll
+++ b/llvm/test/Transforms/SimplifyCFG/switch_create.ll
@@ -34,10 +34,8 @@
 define void @test1_ptr(i32* %V) {
 ; DL-LABEL: @test1_ptr(
 ; DL-NEXT:    [[MAGICPTR:%.*]] = ptrtoint i32* [[V:%.*]] to i32
-; DL-NEXT:    switch i32 [[MAGICPTR]], label [[F:%.*]] [
-; DL-NEXT:    i32 17, label [[T:%.*]]
-; DL-NEXT:    i32 4, label [[T]]
-; DL-NEXT:    ]
+; DL-NEXT:    [[COND:%.*]] = icmp eq i32 [[MAGICPTR]], 4
+; DL-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
 ; DL:       T:
 ; DL-NEXT:    call void @foo1()
 ; DL-NEXT:    ret void
@@ -60,10 +58,8 @@
 define void @test1_ptr_as1(i32 addrspace(1)* %V) {
 ; DL-LABEL: @test1_ptr_as1(
 ; DL-NEXT:    [[MAGICPTR:%.*]] = ptrtoint i32 addrspace(1)* [[V:%.*]] to i16
-; DL-NEXT:    switch i16 [[MAGICPTR]], label [[F:%.*]] [
-; DL-NEXT:    i16 17, label [[T:%.*]]
-; DL-NEXT:    i16 4, label [[T]]
-; DL-NEXT:    ]
+; DL-NEXT:    [[COND:%.*]] = icmp eq i16 [[MAGICPTR]], 4
+; DL-NEXT:    br i1 [[COND]], label [[T:%.*]], label [[F:%.*]]
 ; DL:       T:
 ; DL-NEXT:    call void @foo1()
 ; DL-NEXT:    ret void
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
@@ -8,6 +8,7 @@
 
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Analysis/Loads.h"
 #include "gtest/gtest.h"
 using namespace llvm;
 
@@ -143,23 +144,23 @@
   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.get(), DataLayout("")));
+  EXPECT_EQ(1U, getPointerAlignment(Func.get(), DataLayout("Fi8")));
+  EXPECT_EQ(1U, getPointerAlignment(Func.get(), DataLayout("Fn8")));
+  EXPECT_EQ(2U, getPointerAlignment(Func.get(), DataLayout("Fi16")));
+  EXPECT_EQ(2U, getPointerAlignment(Func.get(), DataLayout("Fn16")));
+  EXPECT_EQ(4U, getPointerAlignment(Func.get(), DataLayout("Fi32")));
+  EXPECT_EQ(4U, getPointerAlignment(Func.get(), 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.get(), DataLayout("")));
+  EXPECT_EQ(1U, getPointerAlignment(Func.get(), DataLayout("Fi8")));
+  EXPECT_EQ(4U, getPointerAlignment(Func.get(), DataLayout("Fn8")));
+  EXPECT_EQ(2U, getPointerAlignment(Func.get(), DataLayout("Fi16")));
+  EXPECT_EQ(4U, getPointerAlignment(Func.get(), DataLayout("Fn16")));
+  EXPECT_EQ(4U, getPointerAlignment(Func.get(), DataLayout("Fi32")));
+  EXPECT_EQ(4U, getPointerAlignment(Func.get(), DataLayout("Fn32")));
 }
 
 } // end namespace