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

[jdoerfert]

Summary

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

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

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

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

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

[jdoerfert]

Update tests and fix errors

[joerg]

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

[jdoerfert]

In D66618#1645472, @joerg wrote:

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

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

[efriedma]

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

llvm/include/llvm/Analysis/Loads.h

82

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

[jdoerfert]

In D66618#1645993, @efriedma wrote:

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

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

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

[jdoerfert]

Update

[jdoerfert]

Improve comment

[jdoerfert]

@reames Would you be OK with this?

[lebedev.ri]

llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll

94

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

[lebedev.ri]

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

[lebedev.ri]

What's the status here?

[jdoerfert]

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

[lebedev.ri]

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

llvm/include/llvm/Analysis/Loads.h

 /// If it is not obviously safe to load from the specified pointer, we do a
 /// quick local scan of the basic block containing ScanFrom, to determine if
 /// the address is already accessed.
 bool isSafeToLoadUnconditionally(Value *V, Type *Ty, unsigned Align,
                                  const DataLayout &DL,
                                  Instruction *ScanFrom = nullptr,
                                  const DominatorTree *DT = nullptr);
 
+/// Returns the number of bytes known to be dereferenceable for the
+/// pointer value \p V and set \p CanBeNull as well as \p IsKnownDeref.
+///
+/// If \p CanBeNull is set by this function if \p V can be null. That is \p V
+/// can have the value "NULL".
+/// If \p IsKnownDeref is set by this function if \p V is known to be
+/// dereferenceable up to the returned number of bytes. That is even if the
+/// pointer can be null, it is known to be dereferenceable.
+///
+/// If NULL is not a valid pointer (in the context of \p V), either \p CanBeNull
+/// or \p IsKnownDeref is set but never both. If NULL is a valid pointer,
+/// \p CanBeNull can be set even if \p IsKnownDeref is set.
+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;
 
 /// Scan backwards to see if we have the value of the given load available
 /// locally within a small number of instructions.
 ///
 /// You can use this function to scan across multiple blocks: after you call

llvm/include/llvm/IR/Value.h

#include "llvm/IR/Value.def"
   /// Returns the original pointer value.  If this is called on a non-pointer
   /// value, it returns 'this'.
   const Value *stripInBoundsOffsets() const;
   Value *stripInBoundsOffsets() {
     return const_cast<Value *>(
                       static_cast<const Value *>(this)->stripInBoundsOffsets());
   }
 
-  /// Returns the number of bytes known to be dereferenceable for the
-  /// pointer value.
-  ///
-  /// If CanBeNull is set by this function the pointer can either be null or be
-  /// dereferenceable up to the returned number of bytes.
-  uint64_t getPointerDereferenceableBytes(const DataLayout &DL,
-                                          bool &CanBeNull) const;
-
-  /// Returns an alignment of the pointer value.
-  ///
-  /// Returns an alignment which is either specified explicitly, e.g. via
-  /// align attribute of a function argument, or guaranteed by DataLayout.
-  unsigned getPointerAlignment(const DataLayout &DL) const;
-
   /// Translate PHI node to its predecessor from the given basic block.
   ///
   /// If this value is a PHI node with CurBB as its parent, return the value in
   /// the PHI node corresponding to PredBB.  If not, return ourself.  This is
   /// useful if you want to know the value something has in a predecessor
   /// block.
   const Value *DoPHITranslation(const BasicBlock *CurBB,
                                 const BasicBlock *PredBB) const;

llvm/lib/Analysis/BasicAliasAnalysis.cpp

 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/Analysis/AliasAnalysis.h"
 #include "llvm/Analysis/AssumptionCache.h"
 #include "llvm/Analysis/CFG.h"
 #include "llvm/Analysis/CaptureTracking.h"
 #include "llvm/Analysis/InstructionSimplify.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/Analysis/LoopInfo.h"
 #include "llvm/Analysis/MemoryBuiltins.h"
 #include "llvm/Analysis/MemoryLocation.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/ValueTracking.h"
 #include "llvm/Analysis/PhiValues.h"
 #include "llvm/IR/Argument.h"
 #include "llvm/IR/Attributes.h"

 /// location size and the fact that null pointers cannot alias here.
 static uint64_t getMinimalExtentFrom(const Value &V,
                                      const LocationSize &LocSize,
                                      const DataLayout &DL,
                                      bool NullIsValidLoc) {
   // If we have dereferenceability information we know a lower bound for the
   // extent as accesses for a lower offset would be valid. We need to exclude
   // the "or null" part if null is a valid pointer.
-  bool CanBeNull;
-  uint64_t DerefBytes = V.getPointerDereferenceableBytes(DL, CanBeNull);
-  DerefBytes = (CanBeNull && NullIsValidLoc) ? 0 : DerefBytes;
+  bool CanBeNull, IsKnownDeref;
+  uint64_t DerefBytes =
+      getPointerDereferenceableBytes(&V, DL, CanBeNull, IsKnownDeref);
+  DerefBytes = (!IsKnownDeref && CanBeNull && NullIsValidLoc) ? 0 : DerefBytes;
   // If queried with a precise location size, we assume that location size to be
   // accessed, thus valid.
   if (LocSize.isPrecise())
     DerefBytes = std::max(DerefBytes, LocSize.getValue());
   return DerefBytes;
 }
 
 /// Returns true if we can prove that the object specified by V has size Size.

llvm/lib/Analysis/CaptureTracking.cpp

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

llvm/lib/Analysis/Loads.cpp

 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Operator.h"
 #include "llvm/IR/Statepoint.h"
 
+#include <limits.h>
+
 using namespace llvm;
 
 static bool isAligned(const Value *Base, const APInt &Offset, unsigned Align,
                       const DataLayout &DL) {
-  APInt BaseAlign(Offset.getBitWidth(), Base->getPointerAlignment(DL));
-
-  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));
 }
 
 static bool isAligned(const Value *Base, unsigned Align, const DataLayout &DL) {
   Type *Ty = Base->getType();
   assert(Ty->isSized() && "must be sized");
   APInt Offset(DL.getTypeStoreSizeInBits(Ty), 0);
   return isAligned(Base, Offset, Align, DL);
 }
 
-/// Test if V is always a pointer to allocated and suitably aligned memory for
-/// a simple load or store.
-static bool isDereferenceableAndAlignedPointer(
-    const Value *V, unsigned Align, const APInt &Size, const DataLayout &DL,
-    const Instruction *CtxI, const DominatorTree *DT,
+static unsigned getPointerAlignment(const Value *V, const DataLayout &DL,
                                     SmallPtrSetImpl<const Value *> &Visited) {
-  // Already visited?  Bail out, we've likely hit unreachable code.
-  if (!Visited.insert(V).second)
-    return false;
+  assert(V->getType()->isPointerTy() && "must be pointer");
 
-  // Note that it is not safe to speculate into a malloc'd region because
-  // malloc may return null.
+  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 MAX_ALIGN;
 
-  // 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);
-
-  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);
+  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);
         }
-
-  // For GEPs, determine if the indexing lands within the allocated object.
-  if (const GEPOperator *GEP = dyn_cast<GEPOperator>(V)) {
+      }
+    }
+  } else if (auto *A = dyn_cast<Argument>(V)) {
+    Align = A->getParamAlignment();
+  } 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();
 
     APInt Offset(DL.getIndexTypeSizeInBits(GEP->getType()), 0);
-    if (!GEP->accumulateConstantOffset(DL, Offset) || Offset.isNegative() ||
-        !Offset.urem(APInt(Offset.getBitWidth(), Align)).isMinValue())
-      return false;
+    if (GEP->accumulateConstantOffset(DL, Offset) && Offset != 0) {
+      auto BaseAlign = getPointerAlignment(Base, DL, Visited);
+      if (BaseAlign <= 1) {
+        // 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();
 
-    // 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);
+      }
+    }
+    // Do not use type information below to improve the alignment.
+    return Align;
+  }
+
+  if (!Align) {
+    Type *Ty = V->getType()->getPointerElementType();
+    if (Ty->isSized())
+      Align = DL.getABITypeAlignment(Ty);
   }
 
-  // For gc.relocate, look through relocations
-  if (const GCRelocateInst *RelocateInst = dyn_cast<GCRelocateInst>(V))
-    return isDereferenceableAndAlignedPointer(
-        RelocateInst->getDerivedPtr(), Align, Size, DL, CtxI, DT, Visited);
-
-  if (const AddrSpaceCastInst *ASC = dyn_cast<AddrSpaceCastInst>(V))
-    return isDereferenceableAndAlignedPointer(ASC->getOperand(0), Align, Size,
-                                              DL, CtxI, DT, Visited);
+  return Align;
+}
 
-  if (const auto *Call = dyn_cast<CallBase>(V))
-    if (auto *RP = getArgumentAliasingToReturnedPointer(Call, true))
-      return isDereferenceableAndAlignedPointer(RP, Align, Size, DL, CtxI, DT,
-                                                Visited);
+unsigned llvm::getPointerAlignment(const Value *V, const DataLayout &DL) {
+  SmallPtrSet<const Value *, 4> Visited;
+  return ::getPointerAlignment(V, DL, Visited);
+}
+
+static uint64_t
+getPointerDereferenceableBytes(const Value *V, const DataLayout &DL,
+                               bool &CanBeNull, bool &IsKnownDeref,
+                               SmallPtrSetImpl<const Value *> &Visited) {
+  assert(V->getType()->isPointerTy() && "must be pointer");
+  CanBeNull = false;
+  IsKnownDeref = true;
+
+  // 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,
 
-  // If we don't know, assume the worst.
-  return false;
+  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 (auto *I = dyn_cast<Instruction>(V))
+    F = I->getFunction();
+
+  IsKnownDeref = !CanBeNull;
+  CanBeNull |= NullPointerIsDefined(F, V->getType()->getPointerAddressSpace());
+  return DerefBytes;
+}
+
+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,
                                               const APInt &Size,
                                               const DataLayout &DL,
                                               const Instruction *CtxI,
                                               const DominatorTree *DT) {
-  SmallPtrSet<const Value *, 32> Visited;
-  return ::isDereferenceableAndAlignedPointer(V, Align, Size, DL, CtxI, DT,
-                                              Visited);
+  bool 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,
                                               unsigned Align,
                                               const DataLayout &DL,
                                               const Instruction *CtxI,
                                               const DominatorTree *DT) {
   // When dereferenceability information is provided by a dereferenceable
   // attribute, we know exactly how many bytes are dereferenceable. If we can
   // determine the exact offset to the attributed variable, we can use that
   // information here.
 
   // Require ABI alignment for loads without alignment specification
   if (Align == 0)
     Align = DL.getABITypeAlignment(Ty);
 
   if (!Ty->isSized())
     return false;
 
-  SmallPtrSet<const Value *, 32> Visited;
   return ::isDereferenceableAndAlignedPointer(
       V, Align,
       APInt(DL.getIndexTypeSizeInBits(V->getType()), DL.getTypeStoreSize(Ty)),
-      DL, CtxI, DT, Visited);
+      DL, CtxI, DT);
 }
 
 bool llvm::isDereferenceablePointer(const Value *V, Type *Ty,
                                     const DataLayout &DL,
                                     const Instruction *CtxI,
                                     const DominatorTree *DT) {
   return isDereferenceableAndAlignedPointer(V, Ty, 1, DL, CtxI, DT);
 }

llvm/lib/Analysis/ValueTracking.cpp

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

llvm/lib/CodeGen/CodeGenPrepare.cpp

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

llvm/lib/IR/ConstantFold.cpp

 // pieces that don't need DataLayout, and the pieces that do. This is to avoid
 // a dependence in IR on Target.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ConstantFold.h"
 #include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/SmallVector.h"
+#include "llvm/Analysis/Loads.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/GlobalAlias.h"
 #include "llvm/IR/GlobalVariable.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Module.h"
case Instruction::And:
             return C1;
         }
 
         // If and'ing the address of a global with a constant, fold it.
         if (CE1->getOpcode() == Instruction::PtrToInt &&
             isa<GlobalValue>(CE1->getOperand(0))) {
           GlobalValue *GV = cast<GlobalValue>(CE1->getOperand(0));
 
-          unsigned GVAlign;
+          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.
             // This is dangerous; on x86, the alignment of the pointer
             // corresponds to the alignment of the function, but might be less
             // than 4 if it isn't explicitly specified.
             // However, a fix for this behaviour was reverted because it
             // increased code size (see https://reviews.llvm.org/D55115)

llvm/lib/IR/Value.cpp

 //
 //===----------------------------------------------------------------------===//
 
 #include "llvm/IR/Value.h"
 #include "LLVMContextImpl.h"
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/ADT/SetVector.h"
+#include "llvm/Analysis/ValueTracking.h"
 #include "llvm/IR/Constant.h"
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/DerivedUser.h"
 #include "llvm/IR/GetElementPtrTypeIterator.h"
 #include "llvm/IR/InstrTypes.h"
 #include "llvm/IR/Instructions.h"
Value::stripAndAccumulateConstantOffsets(const DataLayout &DL, APInt &Offset,
 
   return V;
 }
 
 const Value *Value::stripInBoundsOffsets() const {
   return stripPointerCastsAndOffsets<PSK_InBounds>(this);
 }
 
-uint64_t Value::getPointerDereferenceableBytes(const DataLayout &DL,
-                                               bool &CanBeNull) const {
-  assert(getType()->isPointerTy() && "must be pointer");
-
-  uint64_t DerefBytes = 0;
-  CanBeNull = false;
-  if (const Argument *A = dyn_cast<Argument>(this)) {
-    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;
-    }
-  }
-  return DerefBytes;
-}
-
-unsigned Value::getPointerAlignment(const DataLayout &DL) const {
-  assert(getType()->isPointerTy() && "must be pointer");
-
-  unsigned Align = 0;
-  if (auto *GO = dyn_cast<GlobalObject>(this)) {
-    if (isa<Function>(GO)) {
-      MaybeAlign FunctionPtrAlign = DL.getFunctionPtrAlign();
-      unsigned Align = FunctionPtrAlign ? FunctionPtrAlign->value() : 0;
-      switch (DL.getFunctionPtrAlignType()) {
-      case DataLayout::FunctionPtrAlignType::Independent:
-        return Align;
-      case DataLayout::FunctionPtrAlignType::MultipleOfFunctionAlign:
-        return std::max(Align, GO->getAlignment());
-      }
-    }
-    Align = GO->getAlignment();
-    if (Align == 0) {
-      if (auto *GVar = dyn_cast<GlobalVariable>(GO)) {
-        Type *ObjectType = GVar->getValueType();
-        if (ObjectType->isSized()) {
-          // If the object is defined in the current Module, we'll be giving
-          // it the preferred alignment. Otherwise, we have to assume that it
-          // may only have the minimum ABI alignment.
-          if (GVar->isStrongDefinitionForLinker())
-            Align = DL.getPreferredAlignment(GVar);
-          else
-            Align = DL.getABITypeAlignment(ObjectType);
-        }
-      }
-    }
-  } else if (const Argument *A = dyn_cast<Argument>(this)) {
-    Align = A->getParamAlignment();
-
-    if (!Align && A->hasStructRetAttr()) {
-      // An sret parameter has at least the ABI alignment of the return type.
-      Type *EltTy = cast<PointerType>(A->getType())->getElementType();
-      if (EltTy->isSized())
-        Align = DL.getABITypeAlignment(EltTy);
-    }
-  } else if (const AllocaInst *AI = dyn_cast<AllocaInst>(this)) {
-    Align = AI->getAlignment();
-    if (Align == 0) {
-      Type *AllocatedType = AI->getAllocatedType();
-      if (AllocatedType->isSized())
-        Align = DL.getPrefTypeAlignment(AllocatedType);
-    }
-  } else if (const auto *Call = dyn_cast<CallBase>(this)) {
-    Align = Call->getRetAlignment();
-    if (Align == 0 && Call->getCalledFunction())
-      Align = Call->getCalledFunction()->getAttributes().getRetAlignment();
-  } else if (const LoadInst *LI = dyn_cast<LoadInst>(this))
-    if (MDNode *MD = LI->getMetadata(LLVMContext::MD_align)) {
-      ConstantInt *CI = mdconst::extract<ConstantInt>(MD->getOperand(0));
-      Align = CI->getLimitedValue();
-    }
-
-  return Align;
-}
-
 const Value *Value::DoPHITranslation(const BasicBlock *CurBB,
                                      const BasicBlock *PredBB) const {
   auto *PN = dyn_cast<PHINode>(this);
   if (PN && PN->getParent() == CurBB)
     return PN->getIncomingValueForBlock(PredBB);
   return this;
 }
 

llvm/lib/Target/AArch64/AArch64InstrInfo.h

 
 #ifndef LLVM_LIB_TARGET_AARCH64_AARCH64INSTRINFO_H
 #define LLVM_LIB_TARGET_AARCH64_AARCH64INSTRINFO_H
 
 #include "AArch64.h"
 #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"
 
 #define GET_INSTRINFO_HEADER
 #include "AArch64GenInstrInfo.inc"
 
 namespace llvm {
 

llvm/lib/Target/AArch64/AArch64InstrInfo.td

 def : InstAlias<"prfm $Rt, [$Rn]", (PRFMui prfop:$Rt, GPR64sp:$Rn, 0)>;
 
 //---
 // (literal)
 
 def alignedglobal : PatLeaf<(iPTR iPTR:$label), [{
   if (auto *G = dyn_cast<GlobalAddressSDNode>(N)) {
     const DataLayout &DL = MF->getDataLayout();
-    unsigned Align = G->getGlobal()->getPointerAlignment(DL);
+    unsigned Align = getPointerAlignment(G->getGlobal(), DL);
     return Align >= 4 && G->getOffset() % 4 == 0;
   }
   if (auto *C = dyn_cast<ConstantPoolSDNode>(N))
     return C->getAlignment() >= 4 && C->getOffset() % 4 == 0;
   return false;
 }]>;
 
 def LDRWl : LoadLiteral<0b00, 0, GPR32z, "ldr",

llvm/lib/Transforms/IPO/Attributor.cpp

auto VisitValueCB = [&](Value &V, DerefState &T, bool Stripped) -> bool {
           V.stripAndAccumulateInBoundsConstantOffsets(DL, Offset);
 
       const auto &AA =
           A.getAAFor<AADereferenceable>(*this, IRPosition::value(*Base));
       int64_t DerefBytes = 0;
       if (!Stripped && this == &AA) {
         // Use IR information if we did not strip anything.
         // TODO: track globally.
-        bool CanBeNull;
-        DerefBytes = Base->getPointerDereferenceableBytes(DL, CanBeNull);
+        bool CanBeNull, IsKnownDeref;
+        DerefBytes =
+            getPointerDereferenceableBytes(Base, DL, CanBeNull, IsKnownDeref);
         T.GlobalState.indicatePessimisticFixpoint();
       } else {
         const DerefState &DS = static_cast<const DerefState &>(AA.getState());
         DerefBytes = DS.DerefBytesState.getAssumed();
         T.GlobalState &= DS.GlobalState;
       }
 
       // For now we do not try to "increase" dereferenceability due to negative
void initialize(Attributor &A) override {
     takeAssumedMinimum(MAX_ALIGN);
 
     SmallVector<Attribute, 4> Attrs;
     getAttrs({Attribute::Alignment}, Attrs);
     for (const Attribute &Attr : Attrs)
       takeKnownMaximum(Attr.getValueAsInt());
   }
 
-  // TODO: Provide a helper to determine the implied ABI alignment and check in
-  //       the existing manifest method and a new one for AAAlignImpl that value
-  //       to avoid making the alignment explicit if it did not improve.
+  /// 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,
                        SmallVectorImpl<Attribute> &Attrs) const override {
     if (getAssumedAlign() > 1)
       Attrs.emplace_back(Attribute::getWithAlignment(Ctx, getAssumedAlign()));
   }
struct AAAlignFloating : AAAlignImpl {
   ChangeStatus updateImpl(Attributor &A) override {
     const DataLayout &DL = A.getDataLayout();
 
     auto VisitValueCB = [&](Value &V, AAAlign::StateType &T,
                             bool Stripped) -> bool {
       const auto &AA = A.getAAFor<AAAlign>(*this, IRPosition::value(V));
       if (!Stripped && this == &AA) {
         // Use only IR information if we did not strip anything.
-        T.takeKnownMaximum(V.getPointerAlignment(DL));
+        T.takeKnownMaximum(getPointerAlignment(&V, DL));
         T.indicatePessimisticFixpoint();
       } else {
         // Use abstract attribute information.
         const AAAlign::StateType &DS =
             static_cast<const AAAlign::StateType &>(AA.getState());
         T ^= DS;
       }
       return T.isValidState();

llvm/test/CodeGen/PowerPC/noPermuteFormasking.ll

 ; 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
 define void @test() local_unnamed_addr #0 comdat align 2 {
 ; 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
 ; CHECK-NEXT:  # %bb.1: # %for.body.i.i.i.i.i.i.i
 entry:
   %0 = load float*, float** undef, align 8
   %1 = load i64, i64* undef, align 8
   %add.ptr.i.i.i.i = getelementptr inbounds float, float* %0, i64 undef

 entry:
   %tobool = icmp ugt i32 %a, 67108863
   %mul = select i1 %tobool, i32 1, i32 %b
   %cond = mul nsw i32 %mul, %a
   ret i32 %cond
 }
 
 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
   %mul = select i1 %tobool, i64 %b, i64 1
   %cond = mul nsw i64 %mul, %a
   ret i64 %cond
 }

llvm/test/Transforms/FunctionAttrs/align.ll

 ; ATTRIBUTOR: define align 32 i32* @test4(i32* align 32 "no-capture-maybe-returned" %0, i32* align 32 "no-capture-maybe-returned" %1, i1 %2)
 define i32* @test4(i32* align 32 %0, i32* align 32 %1, i1 %2) #0 {
   %ret = select i1 %2, i32* %0, i32* %1
   ret i32* %ret
 }
 
 ; 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
 }
 
 ; TEST 6
 ; SCC
 ; ATTRIBUTOR: define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @test6_1()
 define i32* @test6_1() #0 {
   %ret = tail call i32* @test6_2()

 ; char* f2(char* a){
 ;     return a?f1(a):f3(&a2);
 ; }
 ;
 ; char* f3(char* a){
 ;     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) "no-capture-maybe-returned" %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
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ %0, %1 ]
   ret i8* %6
 }
 
 ; 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) "no-capture-maybe-returned" %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) "no-capture-maybe-returned" %0)
+; ATTRIBUTOR: %4 = tail call i8* @f1(i8* nonnull align 16 dereferenceable(1) "no-capture-maybe-returned" %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
 
 ; <label>:7:                                      ; preds = %5, %3
   %8 = phi i8* [ %4, %3 ], [ %6, %5 ]
   ret i8* %8
 }
 
 ; 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* nocapture 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* @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
 
 ; <label>:5:                                      ; preds = %1, %3
   %6 = phi i8* [ %4, %3 ], [ @a1, %1 ]
   ret i8* %6
 }
 
 ; TEST 7
 ; Better than IR information
 ; ATTRIBUTOR: define align 32 i32* @test7(i32* returned align 32 "no-capture-maybe-returned" %p)
 define align 4 i32* @test7(i32* align 32 %p) #0 {
   tail call i8* @f1(i8* align 8 dereferenceable(1) @a1)
   ret i32* %p
 }
 
 
 ; 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* nocapture align 4 %a, i32* nocapture align 4 %b, i32* nocapture %c)
   ret void
 }
 

llvm/test/Transforms/FunctionAttrs/noalias_returned.ll

5:                                                ; preds = %1, %3
   ret i8* %6
 }
 
 declare i8* @baz(...) nounwind uwtable
 
 ; 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
 }
 
 ; TEST 6
 declare noalias i8* @strdup(i8* nocapture) nounwind
 

llvm/test/Transforms/InstCombine/PowerPC/aligned-altivec.ll

+; 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"
 
 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
   ret <4 x i32> %a
 }
 
 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
   ret <4 x i32> %a
 }
 
 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*
   call void @llvm.ppc.altivec.stvx(<4 x i32> %d, i8* %hv)
 
   %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*
   call void @llvm.ppc.altivec.stvx(<4 x i32> %d, i8* %hv)
 
   %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
   ret <4 x i32> %a
 }
 
 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
   ret <4 x i32> %a
 }
 
 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*
   call void @llvm.ppc.altivec.stvxl(<4 x i32> %d, i8* %hv)
 
   %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*
   call void @llvm.ppc.altivec.stvxl(<4 x i32> %d, i8* %hv)
 
   %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 }
 attributes #1 = { nounwind readonly }
 

llvm/test/Transforms/InstCombine/PowerPC/aligned-qpx.ll

+; 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"
 
 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>
   %a = fadd <4 x double> %v0e, %vl
   ret <4 x double> %a
 }
 
 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>
   %a = fadd <4 x double> %v0e, %vl
   ret <4 x double> %a
 }
 
 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*
   call void @llvm.ppc.qpx.qvstfs(<4 x double> %d, i8* %hv)
 
   %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*
   call void @llvm.ppc.qpx.qvstfs(<4 x double> %d, i8* %hv)
 
   %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
   ret <4 x double> %a
 }
 
 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
   ret <4 x double> %a
 }
 
 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
   ret <4 x double> %a
 }
 
 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*
   call void @llvm.ppc.qpx.qvstfd(<4 x double> %d, i8* %hv)
 
   %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*
   call void @llvm.ppc.qpx.qvstfd(<4 x double> %d, i8* %hv)
 
   %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*
   call void @llvm.ppc.qpx.qvstfd(<4 x double> %d, i8* %hv)
 
   %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 }
 attributes #1 = { nounwind readonly }
 

llvm/test/Transforms/InstCombine/assume_inevitable.ll

 ; CHECK-NEXT:    [[DUMMY_EQ:%.*]] = icmp ugt i32 [[LOADRES]], 42
 ; CHECK-NEXT:    tail call void @llvm.assume(i1 [[DUMMY_EQ]])
 ; CHECK-NEXT:    [[M_I8:%.*]] = bitcast i64* [[M]] to i8*
 ; CHECK-NEXT:    [[M_A:%.*]] = call i8* @llvm.ptr.annotation.p0i8(i8* nonnull [[M_I8]], i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str, i64 0, i64 0), i8* getelementptr inbounds ([4 x i8], [4 x i8]* @.str1, i64 0, i64 0), i32 2)
 ; CHECK-NEXT:    [[M_X:%.*]] = bitcast i8* [[M_A]] to i64*
 ; 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]]
 ;
 entry:
   %dummy = alloca i8, align 4
   %m = alloca i64
   %0 = load i32, i32* %a, align 4

llvm/test/Transforms/InstCombine/atomic.ll

; CHECK: store atomic float %x, float* %p seq_cst, align 4
   %x = load atomic float, float* %p seq_cst, align 4
   call void @clobber() ;; keep the load around
   store atomic float %x, float* %p seq_cst, align 4
   ret i32 0
 }
 
 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
 }
 
 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
 }
 
 define void @pr27490a(i8** %p1, i8** %p2) {
 ; CHECK-LABEL: define void @pr27490
 ; CHECK: %1 = bitcast i8** %p1 to i64*

llvm/test/Transforms/InstCombine/constant-fold-address-space-pointer.ll

+; 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"
 
 @g = addrspace(3) global i32 89
 
 @const_zero_i8_as1 = addrspace(1) constant i8 0
 @const_zero_i32_as1 = addrspace(1) constant i32 0
 
 @const_zero_i8_as2 = addrspace(2) constant i8 0
 @const_zero_i32_as2 = addrspace(2) constant i32 0
 
 @const_zero_i8_as3 = addrspace(3) constant i8 0
 @const_zero_i32_as3 = addrspace(3) constant i32 0
 
 ; Test constant folding of inttoptr (ptrtoint constantexpr)
 ; 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
 }
 
 ; 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
 }
 
 ; Different address spaces that are the same size, but they are
 ; 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
 }
 
 ; Make sure we don't introduce a bitcast between different sized
 ; 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
 }
 
 ; 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
 }
 
 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)
 }
 
 ; Test that mask happens when the destination pointer is smaller than
 ; 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)
 }
 
 ; Address space 0 is too small for the correct mask, should mask with
 ; 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
 }
 
 @g_float_as3 = addrspace(3) global float zeroinitializer
 @g_v4f_as3 = addrspace(3) global <4 x float> zeroinitializer
 
 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
 }
 
 @i32_array_as3 = addrspace(3) global [10 x i32] zeroinitializer
 
 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]]
+;
 }
 
 %struct.foo = type { float, float, [4 x i32], i32 addrspace(3)* }
 
 @constant_fold_global_ptr = addrspace(3) global %struct.foo {
   float 0.0,
   float 0.0,
   [4 x i32] zeroinitializer,
   i32 addrspace(3)* getelementptr ([10 x i32], [10 x i32] addrspace(3)* @i32_array_as3, i64 0, i64 0)
 }
 
 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]]
+;
 }
 
 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
 }
 
 @constant_data_as3 = addrspace(3) constant [5 x i32] [i32 1, i32 2, i32 3, i32 4, i32 5]
 
 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
 }
 
 @a = addrspace(1) constant i32 9
 @b = addrspace(1) constant i32 23
 @c = addrspace(1) constant i32 34
 @d = addrspace(1) constant i32 99
 
 @ptr_array = addrspace(2) constant [4 x i32 addrspace(1)*] [ i32 addrspace(1)* @a, i32 addrspace(1)* @b, i32 addrspace(1)* @c, i32 addrspace(1)* @d]
 @indirect = addrspace(0) constant i32 addrspace(1)* addrspace(2)* getelementptr inbounds ([4 x i32 addrspace(1)*], [4 x i32 addrspace(1)*] addrspace(2)* @ptr_array, i1 0, i32 2)
 
 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
   ret i32 %b
 }
 
 @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
 }

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

+; 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"
 
 @G1 = global i32 42, align 1
 @G2 = global i32 42
 @G3 = global [4 x i8] zeroinitializer, align 1
 
 @A1 = alias i32, bitcast (i8* getelementptr inbounds ([4 x i8], [4 x i8]* @G3, i32 0, i32 2) to i32*)
 @A2 = alias i32, inttoptr (i64 and (i64 ptrtoint (i8* getelementptr inbounds ([4 x i8], [4 x i8]* @G3, i32 0, i32 3) to i64), i64 -4) to i32*)
 
 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)
 }
 
 define i64 @g2() {
 ; 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)
 }
 

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

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

llvm/test/Transforms/InstCombine/gep-addrspace.ll

 @scalar = internal addrspace(3) global float 0.000000e+00, align 4
 
 define void @keep_necessary_addrspacecast(i64 %i, float** %out0, float** %out1) {
 ; CHECK-LABEL: @keep_necessary_addrspacecast(
 ; CHECK-NEXT:    [[T01:%.*]] = getelementptr [256 x float], [256 x float] addrspace(3)* @array, i64 0, i64 [[I:%.*]]
 ; 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
   %t1 = getelementptr [0 x float], [0 x float]* addrspacecast (float addrspace(3)* @scalar to [0 x float]*), i64 0, i64 %i
   store float* %t0, float** %out0, align 4
   store float* %t1, float** %out1, align 4
   ret void
 }

llvm/test/Transforms/InstCombine/load-bitcast-vec.ll

;
   %bc = bitcast <4 x float>* %p to i8*
   %r = load i8, i8* %bc, align 16
   ret i8 %r
 }
 
 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*
   %r = load i8, i8* %bc, align 4
   ret i8 %r
 }
 
 define float @matching_scalar_small_deref(<4 x float>* dereferenceable(15) %p) {

llvm/test/Transforms/InstCombine/masked_intrinsics.ll

 ; CHECK-NEXT:    ret <2 x double> [[PASSTHRU:%.*]]
 ;
   %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %ptr, i32 1, <2 x i1> zeroinitializer, <2 x double> %passthru)
   ret <2 x double> %res
 }
 
 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)
   ret <2 x double> %res
 }
 
 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)
   ret <2 x double> %res
 }
 
 @G = external global i8
 
;
   %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %ptr, i32 4, <2 x i1> %mask, <2 x double> %ptv2)
   ret <2 x double> %res
 }
 
 define <2 x double> @load_speculative(<2 x double>* dereferenceable(16) %ptr,
 ; 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]]
 ;
   double %pt, <2 x i1> %mask)  {
   %ptv1 = insertelement <2 x double> undef, double %pt, i64 0
   %ptv2 = insertelement <2 x double> %ptv1, double %pt, i64 1
   %res = call <2 x double> @llvm.masked.load.v2f64.p0v2f64(<2 x double>* %ptr, i32 4, <2 x i1> %mask, <2 x double> %ptv2)
   ret <2 x double> %res

 ; CHECK-NEXT:    ret void
 ;
   call void @llvm.masked.store.v2f64.p0v2f64(<2 x double> %val, <2 x double>* %ptr, i32 4, <2 x i1> zeroinitializer)
   ret void
 }
 
 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>)
   ret void
 }
 
 define void @store_demandedelts(<2 x double>* %ptr, double %val)  {
 ; CHECK-LABEL: @store_demandedelts(

llvm/test/Transforms/InstCombine/memcpy-from-global.ll

; use @G instead of %A
   ret void
 }
 
 define void @test2_addrspacecast() {
 ; CHECK-LABEL: @test2_addrspacecast(
 ; 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
 ;
   %A = alloca %T
   %B = alloca %T
   %a = addrspacecast %T* %A to i8 addrspace(1)*
   %b = addrspacecast %T* %B to i8 addrspace(1)*
 

llvm/test/Transforms/InstCombine/phi.ll

bb1:
   br label %bb2
 
 bb2:
   %E = phi i32 [ %C, %bb ], [ %D, %bb1 ]
   ret i32 %E
 ; 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
 
 }
 
 define i32 @test10(i32* %A, i32* %B) {
 entry:
   %c = icmp eq i32* %A, null
   br i1 %c, label %bb1, label %bb

llvm/test/Transforms/InstCombine/ptr-int-cast.ll

 ; RUN: opt < %s -instcombine -S | FileCheck %s
 target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128"
 
 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
 }
 
 define i32* @test2(i128 %x) nounwind {
 entry:
 ; CHECK: test2
 ; CHECK: inttoptr i64 %0 to i32*

llvm/test/Transforms/InstCombine/rem.ll

;
   %D = srem i32 %A, %C
   %E = icmp ne i32 %D, 0
   ret i1 %E
 }
 
 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]]
 ;
   %B = srem i32 %A, 2147483648 ; signbit
   store i32 %B, i32* %remdst, align 1 ; extra use of rem
   %C = icmp ne i32 %B, 0
   ret i1 %C
 }

llvm/test/Transforms/InstCombine/scalarization.ll

 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
 ; RUN: opt -instcombine -S < %s | FileCheck %s
 
 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]]
 ;
   %x = load <4 x i32>, <4 x i32>* %p, align 4
   %ext = extractelement <4 x i32> %x, i32 1
   ret i32 %ext
 }
 

 ;
   %x = load volatile <4 x double>, <4 x double>* %p
   %ext = extractelement <4 x double> %x, i32 2
   ret double %ext
 }
 
 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]]
 ;
   %x = load <4 x double>, <4 x double>* %p, align 8
   %ext = extractelement <4 x double> %x, i32 0
   store <4 x double> %x, <4 x double>* %p2
   ret double %ext

llvm/test/Transforms/InstCombine/store.ll

 ; "if then"
 define void @test5(i1 %C, i32* %P) {
 ; CHECK-LABEL: @test5(
 ; CHECK-NEXT:    br i1 [[C:%.*]], label [[COND:%.*]], label [[CONT:%.*]]
 ; CHECK:       Cond:
 ; 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
   br i1 %C, label %Cond, label %Cont
 
 Cond:
   store i32 -987654321, i32* %P, align 1
   br label %Cont

llvm/test/Transforms/InstCombine/trunc-load.ll

 }
 
 ; Negative test - extra use means we would not eliminate the original load.
 
 declare void @use(i64)
 
 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]]
 ;
   %x = load i64, i64* %ptr, align 2
   call void @use(i64 %x)
   %r = trunc i64 %x to i32
   ret i32 %r
 }
 
 ; Negative test - don't create a load if the type is not allowed by the data-layout.
 
 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]]
 ;
   %x = load i64, i64* %ptr, align 2
   %r = trunc i64 %x to i8
   ret i8 %r
 }
 

llvm/test/Transforms/LoadStoreVectorizer/AMDGPU/merge-stores-private.ll

 
 ; ELT8-UNALIGNED: store <2 x i32> <i32 9, i32 1>, <2 x i32> addrspace(5)* %1, align 1
 ; ELT8-UNALIGNED: store <2 x i32> <i32 23, i32 19>, <2 x i32> addrspace(5)* %2, align 1
 
 ; ELT4-UNALIGNED: store i32
 ; 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
 
   store i32 9, i32 addrspace(5)* %out, align 1
   store i32 1, i32 addrspace(5)* %out.gep.1, align 1
   store i32 23, i32 addrspace(5)* %out.gep.2, align 1
   store i32 19, i32 addrspace(5)* %out.gep.3, align 1

 
 ; ELT8-UNALIGNED: store <2 x i32>
 ; ELT8-UNALIGNED: store <2 x i32>
 
 ; ELT4-UNALIGNED: store i32
 ; 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
 
   store i32 9, i32 addrspace(5)* %out, align 2
   store i32 1, i32 addrspace(5)* %out.gep.1, align 2
   store i32 23, i32 addrspace(5)* %out.gep.2, align 2
   store i32 19, i32 addrspace(5)* %out.gep.3, align 2

 
 ; ALL-LABEL: @merge_private_store_4_vector_elts_loads_v4i8_align1(
 ; ALIGNED: store i8
 ; ALIGNED: store i8
 ; ALIGNED: store i8
 ; 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
 
   store i8 9, i8 addrspace(5)* %out, align 1
   store i8 1, i8 addrspace(5)* %out.gep.1, align 1
   store i8 23, i8 addrspace(5)* %out.gep.2, align 1
   store i8 19, i8 addrspace(5)* %out.gep.3, align 1
define amdgpu_kernel void @merge_private_store_4_vector_elts_loads_v2i16(i16 addrspace(5)* %out) #0 {
   ret void
 }
 
 ; ALL-LABEL: @merge_private_store_4_vector_elts_loads_v2i16_align2(
 ; ALIGNED: store i16
 ; 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
   store i16 12, i16 addrspace(5)* %out.gep.1, align 2
   ret void
 }
 
 ; ALL-LABEL: @merge_private_store_4_vector_elts_loads_v2i16_align1(

 ; ELT4-UNALIGNED: store i32
 ; ELT4-UNALIGNED: store i32
 ; ELT4-UNALIGNED: store i32
 
 ; ELT8-UNALIGNED: store <2 x i32>
 ; 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
 
   store i32 9, i32 addrspace(5)* %out, align 1
   store i32 1, i32 addrspace(5)* %out.gep.1, align 1
   store i32 23, i32 addrspace(5)* %out.gep.2, align 1
   ret void
 }
 
 ; ALL-LABEL: @merge_private_store_3_vector_elts_loads_v4i8_align1(
 ; ALIGNED: store i8
 ; ALIGNED: store i8
 ; 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
 
   store i8 9, i8 addrspace(5)* %out, align 1
   store i8 1, i8 addrspace(5)* %out.gep.1, align 1
   store i8 23, i8 addrspace(5)* %out.gep.2, align 1
   ret void
 }
 
 attributes #0 = { nounwind }

llvm/test/Transforms/LoopVectorize/AArch64/aarch64-predication.ll

 ; COST:        LV: Found an estimated cost of 4 for VF 2 For instruction: %tmp4 = udiv i64 %tmp2, %tmp3
 ;
 ; CHECK-LABEL: @predicated_udiv_scalarized_operand(
 ; CHECK:       vector.body:
 ; CHECK-NEXT:    [[INDEX:%.*]] = phi i64 [ 0, %entry ], [ [[INDEX_NEXT:%.*]], %[[PRED_UDIV_CONTINUE2:.*]] ]
 ; 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:.*]]
 ; CHECK:       [[PRED_UDIV_IF]]:
 ; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <2 x i64> [[WIDE_LOAD]], i32 0
 ; CHECK-NEXT:    [[TMP5:%.*]] = add nsw i64 [[TMP4]], %x
 ; CHECK-NEXT:    [[TMP6:%.*]] = extractelement <2 x i64> [[WIDE_LOAD]], i32 0
 ; CHECK-NEXT:    [[TMP7:%.*]] = udiv i64 [[TMP6]], [[TMP5]]

llvm/test/Transforms/LoopVectorize/X86/consecutive-ptr-uniforms.ll

 ; CHECK-NEXT:    [[TMP0:%.*]] = getelementptr inbounds %data, %data* %d, i64 0, i32 3, i64 [[OFFSET_IDX]]
 ; CHECK-NEXT:    [[TMP1:%.*]] = bitcast float* [[TMP0]] to <80 x float>*
 ; CHECK-NEXT:    [[WIDE_VEC:%.*]] = load <80 x float>, <80 x float>* [[TMP1]], align 4
 ; CHECK-NEXT:    [[STRIDED_VEC:%.*]] = shufflevector <80 x float> [[WIDE_VEC]], <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:    [[TMP2:%.*]] = fmul <16 x float> [[BROADCAST_SPLAT]], [[STRIDED_VEC]]
 ; 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>)
 ; CHECK-NEXT:    [[INDEX_NEXT]] = add i64 [[INDEX]], 16
 ; CHECK-NEXT:    [[VEC_IND_NEXT]] = add <16 x i64> [[VEC_IND]], <i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80, i64 80>
 ; CHECK:         br i1 {{.*}}, label %middle.block, label %vector.body
 
 %data = type { [32000 x float], [3 x i32], [4 x i8], [32000 x float] }

llvm/test/Transforms/LoopVectorize/consecutive-ptr-uniforms.ll

 ; INTER-NEXT:  LV: Found uniform instruction: %tmp1 = bitcast i64* %tmp0 to i8*
 ; INTER-NEXT:  LV: Found uniform instruction: %tmp0 = getelementptr inbounds i64, i64* %A, i64 %i
 ; INTER-NEXT:  LV: Found uniform instruction: %i = phi i64 [ 0, %entry ], [ %i.next, %for.body ]
 ; INTER-NEXT:  LV: Found uniform instruction: %i.next = add nuw nsw i64 %i, 1
 ; INTER:       vector.body:
 ; 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]]
 ; INTER-NEXT:    [[TMP7:%.*]] = getelementptr inbounds i8, i8* %B, i64 [[INDEX]]
 ; INTER-NEXT:    [[TMP8:%.*]] = bitcast i8* [[TMP7]] to <4 x i8>*
 ; INTER-NEXT:    store <4 x i8> [[TMP6]], <4 x i8>* [[TMP8]], align 1
 ; INTER-NEXT:    [[INDEX_NEXT]] = add i64 [[INDEX]], 4
 ; INTER:         br i1 {{.*}}, label %middle.block, label %vector.body

llvm/test/Transforms/SLPVectorizer/AArch64/getelementptr.ll

 ; CHECK-NEXT:    [[TMP5:%.*]] = extractelement <2 x i32> [[TMP4]], i32 0
 ; CHECK-NEXT:    [[T4:%.*]] = shl nsw i32 [[TMP5]], 1
 ; CHECK-NEXT:    [[TMP6:%.*]] = insertelement <4 x i32> undef, i32 [[T4]], i32 0
 ; CHECK-NEXT:    [[TMP7:%.*]] = shufflevector <4 x i32> [[TMP6]], <4 x i32> undef, <4 x i32> zeroinitializer
 ; CHECK-NEXT:    [[TMP8:%.*]] = add nsw <4 x i32> [[TMP7]], [[TMP2]]
 ; 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
 ; CHECK-NEXT:    [[TMP21]] = add nsw <2 x i32> [[TMP19]], [[TMP20]]
 ; CHECK-NEXT:    [[TMP22:%.*]] = extractelement <2 x i32> [[TMP21]], i32 0
 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[TMP22]], [[N]]
 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]]
 ;

 ; CHECK-NEXT:    [[SUM_0_LCSSA:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[TMP2]], [[FOR_COND_CLEANUP_LOOPEXIT:%.*]] ]
 ; CHECK-NEXT:    ret i32 [[SUM_0_LCSSA]]
 ; CHECK:       for.body:
 ; CHECK-NEXT:    [[TMP3:%.*]] = phi <2 x i32> [ zeroinitializer, [[FOR_BODY_PREHEADER]] ], [ [[TMP18]], [[FOR_BODY]] ]
 ; CHECK-NEXT:    [[TMP4:%.*]] = extractelement <2 x i32> [[TMP3]], i32 0
 ; 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
 ; CHECK-NEXT:    [[TMP10:%.*]] = add nsw <2 x i32> [[TMP9]], [[TMP1]]
 ; 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
 ; CHECK-NEXT:    [[TMP18]] = add nsw <2 x i32> [[TMP16]], [[TMP17]]
 ; CHECK-NEXT:    [[TMP19:%.*]] = extractelement <2 x i32> [[TMP18]], i32 0
 ; CHECK-NEXT:    [[EXITCOND:%.*]] = icmp eq i32 [[TMP19]], [[N]]
 ; CHECK-NEXT:    br i1 [[EXITCOND]], label [[FOR_COND_CLEANUP_LOOPEXIT]], label [[FOR_BODY]]
 ;

llvm/test/Transforms/SimplifyCFG/switch_create-custom-dl.ll

 F:              ; preds = %0
   call void @foo2( )
   ret void
 }
 
 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
 ; CHECK:       F:
 ; CHECK-NEXT:    call void @foo2()
 ; CHECK-NEXT:    ret void
 ;
   %C1 = icmp eq i32* %V, inttoptr (i32 4 to i32*)
   %C2 = icmp eq i32* %V, inttoptr (i32 17 to i32*)
   %CN = or i1 %C1, %C2            ; <i1> [#uses=1]
   br i1 %CN, label %T, label %F
 T:              ; preds = %0
   call void @foo1( )
   ret void
 F:              ; preds = %0
   call void @foo2( )
   ret void
 }
 
 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
 ; CHECK:       F:
 ; CHECK-NEXT:    call void @foo2()
 ; CHECK-NEXT:    ret void
 ;
   %C1 = icmp eq i32 addrspace(1)* %V, inttoptr (i32 4 to i32 addrspace(1)*)

llvm/test/Transforms/SimplifyCFG/switch_create.ll

 F:              ; preds = %0
   call void @foo2( )
   ret void
 }
 
 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
 ; DL:       F:
 ; DL-NEXT:    call void @foo2()
 ; DL-NEXT:    ret void
 ;
   %C1 = icmp eq i32* %V, inttoptr (i32 4 to i32*)
   %C2 = icmp eq i32* %V, inttoptr (i32 17 to i32*)
   %CN = or i1 %C1, %C2            ; <i1> [#uses=1]
   br i1 %CN, label %T, label %F
 T:              ; preds = %0
   call void @foo1( )
   ret void
 F:              ; preds = %0
   call void @foo2( )
   ret void
 }
 
 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
 ; DL:       F:
 ; DL-NEXT:    call void @foo2()
 ; DL-NEXT:    ret void
 ;
   %C1 = icmp eq i32 addrspace(1)* %V, inttoptr (i32 4 to i32 addrspace(1)*)

llvm/unittests/IR/FunctionTest.cpp

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

 }
 
 TEST(FunctionTest, GetPointerAlignment) {
   LLVMContext Context;
   Type *VoidType(Type::getVoidTy(Context));
   FunctionType *FuncType(FunctionType::get(VoidType, false));
   std::unique_ptr<Function> Func(Function::Create(
       FuncType, GlobalValue::ExternalLinkage));
-  EXPECT_EQ(0U, Func->getPointerAlignment(DataLayout("")));
-  EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fi8")));
-  EXPECT_EQ(1U, Func->getPointerAlignment(DataLayout("Fn8")));
-  EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fi16")));
-  EXPECT_EQ(2U, Func->getPointerAlignment(DataLayout("Fn16")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fi32")));
-  EXPECT_EQ(4U, Func->getPointerAlignment(DataLayout("Fn32")));
+  EXPECT_EQ(0U, getPointerAlignment(Func.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