No review requested: precursor changes for D44748

[george.burgess.iv]

Summary

This is a set of three or four individually small and targeted patches merged together. The intent is for them to all be trivially NFC (modulo the LocationSize::print changes, which are the cause of the test updates) and to be individually targeted enough to land with post-commit review.

So, no review is requested. I just don't like posting a patch that won't apply to anything upstream, and these changes don't really make much sense if D44748 doesn't land, so I'm reluctant to just commit them on their own. :)

[george.burgess.iv]

Landed these a while back; closing.

include/llvm/Analysis/MemoryLocation.h

 class MemIntrinsic;
 class AtomicMemTransferInst;
 class AtomicMemIntrinsic;
 class AnyMemTransferInst;
 class AnyMemIntrinsic;
 class TargetLibraryInfo;
 
 // Represents the size of a MemoryLocation. Logically, it's an
-// Optional<uint64_t>, with a special UnknownSize value from `MemoryLocation`.
-using LocationSize = uint64_t;
+// Optional<uint64_t>.
+//
+// We plan to use it for more soon, but we're trying to transition to this brave
+// new world in small, easily-reviewable pieces; please see D44748.
+class LocationSize {
+  enum : uint64_t {
+    Unknown = ~uint64_t(0),
+    MapEmpty = Unknown - 1,
+    MapTombstone = Unknown - 2,
+
+    // The maximum value we can represent without falling back to 'unknown'.
+    MaxValue = MapTombstone - 1,
+  };
+
+  uint64_t Value;
+
+  // Hack to support implicit construction. This should disappear when the
+  // public LocationSize ctor goes away.
+  enum DirectConstruction { Direct };
+
+  constexpr LocationSize(uint64_t Raw, DirectConstruction): Value(Raw) {}
+
+public:
+  constexpr LocationSize(uint64_t Raw)
+      : Value(Raw > MaxValue ? Unknown : Raw) {}
+
+  static LocationSize precise(uint64_t Value) { return LocationSize(Value); }
+  constexpr static LocationSize unknown() {
+    return LocationSize(Unknown, Direct);
+  }
+
+  // Sentinel values, generally used for maps.
+  constexpr static LocationSize mapTombstone() {
+    return LocationSize(MapTombstone, Direct);
+  }
+  constexpr static LocationSize mapEmpty() {
+    return LocationSize(MapEmpty, Direct);
+  }
+
+  bool hasValue() const { return Value != Unknown; }
+  uint64_t getValue() const {
+    assert(hasValue() && "Getting value from an unknown LocationSize!");
+    return Value;
+  }
+
+  bool operator==(const LocationSize &Other) const {
+    return Value == Other.Value;
+  }
+
+  bool operator!=(const LocationSize &Other) const {
+    return !(*this == Other);
+  }
+
+  void print(raw_ostream &OS) const;
+
+  // Returns an opaque value that represents this LocationSize. Cannot be
+  // reliably converted back into a LocationSize.
+  uint64_t toRaw() const { return Value; }
+
+  // NOTE: These comparison operators will go away with D44748. Please don't
+  // rely on them.
+  bool operator<(const LocationSize &Other) const {
+    return Value < Other.Value;
+  }
+
+  bool operator>(const LocationSize &Other) const {
+    return Other < *this;
+  }
+};
+
+inline raw_ostream &operator<<(raw_ostream &OS, LocationSize Size) {
+  Size.print(OS);
+  return OS;
+}
 
 /// Representation for a specific memory location.
 ///
 /// This abstraction can be used to represent a specific location in memory.
 /// The goal of the location is to represent enough information to describe
 /// abstract aliasing, modification, and reference behaviors of whatever
 /// value(s) are stored in memory at the particular location.
 ///
MemoryLocation getWithoutAATags() const {
     return Copy;
   }
 
   bool operator==(const MemoryLocation &Other) const {
     return Ptr == Other.Ptr && Size == Other.Size && AATags == Other.AATags;
   }
 };
 
-// Specialize DenseMapInfo for MemoryLocation.
+// Specialize DenseMapInfo.
+template <> struct DenseMapInfo<LocationSize> {
+  static inline LocationSize getEmptyKey() {
+    return LocationSize::mapEmpty();
+  }
+  static inline LocationSize getTombstoneKey() {
+    return LocationSize::mapTombstone();
+  }
+  static unsigned getHashValue(const LocationSize &Val) {
+    return DenseMapInfo<uint64_t>::getHashValue(Val.toRaw());
+  }
+  static bool isEqual(const LocationSize &LHS, const LocationSize &RHS) {
+    return LHS == RHS;
+  }
+};
+
 template <> struct DenseMapInfo<MemoryLocation> {
   static inline MemoryLocation getEmptyKey() {
-    return MemoryLocation(DenseMapInfo<const Value *>::getEmptyKey(), 0);
+    return MemoryLocation(DenseMapInfo<const Value *>::getEmptyKey(),
+                          DenseMapInfo<LocationSize>::getEmptyKey());
   }
   static inline MemoryLocation getTombstoneKey() {
-    return MemoryLocation(DenseMapInfo<const Value *>::getTombstoneKey(), 0);
+    return MemoryLocation(DenseMapInfo<const Value *>::getTombstoneKey(),
+                          DenseMapInfo<LocationSize>::getTombstoneKey());
   }
   static unsigned getHashValue(const MemoryLocation &Val) {
     return DenseMapInfo<const Value *>::getHashValue(Val.Ptr) ^
            DenseMapInfo<LocationSize>::getHashValue(Val.Size) ^
            DenseMapInfo<AAMDNodes>::getHashValue(Val.AATags);
   }
   static bool isEqual(const MemoryLocation &LHS, const MemoryLocation &RHS) {
     return LHS == RHS;
   }
 };
 }
 
 #endif

lib/Analysis/BasicAliasAnalysis.cpp

ModRefInfo BasicAAResult::getModRefInfo(ImmutableCallSite CS1,
 
   // The AAResultBase base class has some smarts, lets use them.
   return AAResultBase::getModRefInfo(CS1, CS2);
 }
 
 /// Provide ad-hoc rules to disambiguate accesses through two GEP operators,
 /// both having the exact same pointer operand.
 static AliasResult aliasSameBasePointerGEPs(const GEPOperator *GEP1,
-                                            LocationSize V1Size,
+                                            LocationSize MaybeV1Size,
                                             const GEPOperator *GEP2,
-                                            LocationSize V2Size,
+                                            LocationSize MaybeV2Size,
                                             const DataLayout &DL) {
   assert(GEP1->getPointerOperand()->stripPointerCastsAndInvariantGroups() ==
              GEP2->getPointerOperand()->stripPointerCastsAndInvariantGroups() &&
          GEP1->getPointerOperandType() == GEP2->getPointerOperandType() &&
          "Expected GEPs with the same pointer operand");
 
   // Try to determine whether GEP1 and GEP2 index through arrays, into structs,
   // such that the struct field accesses provably cannot alias.
   // We also need at least two indices (the pointer, and the struct field).
   if (GEP1->getNumIndices() != GEP2->getNumIndices() ||
       GEP1->getNumIndices() < 2)
     return MayAlias;
 
   // If we don't know the size of the accesses through both GEPs, we can't
   // determine whether the struct fields accessed can't alias.
-  if (V1Size == MemoryLocation::UnknownSize ||
-      V2Size == MemoryLocation::UnknownSize)
+  if (MaybeV1Size == MemoryLocation::UnknownSize ||
+      MaybeV2Size == MemoryLocation::UnknownSize)
     return MayAlias;
 
+  const uint64_t V1Size = MaybeV1Size.getValue();
+  const uint64_t V2Size = MaybeV2Size.getValue();
+
   ConstantInt *C1 =
       dyn_cast<ConstantInt>(GEP1->getOperand(GEP1->getNumOperands() - 1));
   ConstantInt *C2 =
       dyn_cast<ConstantInt>(GEP2->getOperand(GEP2->getNumOperands() - 1));
 
   // If the last (struct) indices are constants and are equal, the other indices
   // might be also be dynamically equal, so the GEPs can alias.
   if (C1 && C2 && C1->getSExtValue() == C2->getSExtValue())

 //
 // Assume %f1 and %f0 alias. Then %f1 would point into the object allocated
 // by %alloca. Since the %f1 GEP is inbounds, that means %random must also
 // point into the same object. But since %f0 points to the beginning of %alloca,
 // the highest %f1 can be is (%alloca + 3). This means %random can not be higher
 // than (%alloca - 1), and so is not inbounds, a contradiction.
 bool BasicAAResult::isGEPBaseAtNegativeOffset(const GEPOperator *GEPOp,
       const DecomposedGEP &DecompGEP, const DecomposedGEP &DecompObject,
-      LocationSize ObjectAccessSize) {
+      LocationSize MaybeObjectAccessSize) {
   // If the object access size is unknown, or the GEP isn't inbounds, bail.
-  if (ObjectAccessSize == MemoryLocation::UnknownSize || !GEPOp->isInBounds())
+  if (MaybeObjectAccessSize == MemoryLocation::UnknownSize ||
+      !GEPOp->isInBounds())
     return false;
 
+  const uint64_t ObjectAccessSize = MaybeObjectAccessSize.getValue();
+
   // We need the object to be an alloca or a globalvariable, and want to know
   // the offset of the pointer from the object precisely, so no variable
   // indices are allowed.
   if (!(isa<AllocaInst>(DecompObject.Base) ||
         isa<GlobalVariable>(DecompObject.Base)) ||
       !DecompObject.VarIndices.empty())
     return false;
 
BasicAAResult::aliasGEP(const GEPOperator *GEP1, LocationSize V1Size,
 
   // If there is a constant difference between the pointers, but the difference
   // is less than the size of the associated memory object, then we know
   // that the objects are partially overlapping.  If the difference is
   // greater, we know they do not overlap.
   if (GEP1BaseOffset != 0 && DecompGEP1.VarIndices.empty()) {
     if (GEP1BaseOffset >= 0) {
       if (V2Size != MemoryLocation::UnknownSize) {
-        if ((uint64_t)GEP1BaseOffset < V2Size)
+        if ((uint64_t)GEP1BaseOffset < V2Size.getValue())
           return PartialAlias;
         return NoAlias;
       }
     } else {
       // We have the situation where:
       // +                +
       // | BaseOffset     |
       // ---------------->|
       // |-->V1Size       |-------> V2Size
       // GEP1             V2
       // We need to know that V2Size is not unknown, otherwise we might have
       // stripped a gep with negative index ('gep <ptr>, -1, ...).
       if (V1Size != MemoryLocation::UnknownSize &&
           V2Size != MemoryLocation::UnknownSize) {
-        if (-(uint64_t)GEP1BaseOffset < V1Size)
+        if (-(uint64_t)GEP1BaseOffset < V1Size.getValue())
           return PartialAlias;
         return NoAlias;
       }
     }
   }
 
   if (!DecompGEP1.VarIndices.empty()) {
     uint64_t Modulo = 0;
if (!DecompGEP1.VarIndices.empty()) {
 
     Modulo = Modulo ^ (Modulo & (Modulo - 1));
 
     // We can compute the difference between the two addresses
     // mod Modulo. Check whether that difference guarantees that the
     // two locations do not alias.
     uint64_t ModOffset = (uint64_t)GEP1BaseOffset & (Modulo - 1);
     if (V1Size != MemoryLocation::UnknownSize &&
-        V2Size != MemoryLocation::UnknownSize && ModOffset >= V2Size &&
-        V1Size <= Modulo - ModOffset)
+        V2Size != MemoryLocation::UnknownSize &&
+        ModOffset >= V2Size.getValue() &&
+        V1Size.getValue() <= Modulo - ModOffset)
       return NoAlias;
 
     // If we know all the variables are positive, then GEP1 >= GEP1BasePtr.
     // If GEP1BasePtr > V2 (GEP1BaseOffset > 0) then we know the pointers
     // don't alias if V2Size can fit in the gap between V2 and GEP1BasePtr.
-    if (AllPositive && GEP1BaseOffset > 0 && V2Size <= (uint64_t)GEP1BaseOffset)
+    if (AllPositive && GEP1BaseOffset > 0 &&
+        V2Size != MemoryLocation::UnknownSize &&
+        V2Size.getValue() <= (uint64_t)GEP1BaseOffset)
       return NoAlias;
 
     if (constantOffsetHeuristic(DecompGEP1.VarIndices, V1Size, V2Size,
                                 GEP1BaseOffset, &AC, DT))
       return NoAlias;
   }
 
   // Statically, we can see that the base objects are the same, but the
if (O1 != O2) {
     if (isEscapeSource(O2) && isNonEscapingLocalObject(O1))
       return NoAlias;
   }
 
   // If the size of one access is larger than the entire object on the other
   // side, then we know such behavior is undefined and can assume no alias.
   bool NullIsValidLocation = NullPointerIsDefined(&F);
   if ((V1Size != MemoryLocation::UnknownSize &&
-       isObjectSmallerThan(O2, V1Size, DL, TLI, NullIsValidLocation)) ||
+       isObjectSmallerThan(O2, V1Size.getValue(), DL, TLI,
+                           NullIsValidLocation)) ||
       (V2Size != MemoryLocation::UnknownSize &&
-       isObjectSmallerThan(O1, V2Size, DL, TLI, NullIsValidLocation)))
+       isObjectSmallerThan(O1, V2Size.getValue(), DL, TLI,
+                           NullIsValidLocation)))
     return NoAlias;
 
   // Check the cache before climbing up use-def chains. This also terminates
   // otherwise infinitely recursive queries.
   LocPair Locs(MemoryLocation(V1, V1Size, V1AAInfo),
                MemoryLocation(V2, V2Size, V2AAInfo));
   if (V1 > V2)
     std::swap(Locs.first, Locs.second);
if (Result != MayAlias)
       return AliasCache[Locs] = Result;
   }
 
   // If both pointers are pointing into the same object and one of them
   // accesses the entire object, then the accesses must overlap in some way.
   if (O1 == O2)
     if (V1Size != MemoryLocation::UnknownSize &&
         V2Size != MemoryLocation::UnknownSize &&
-        (isObjectSize(O1, V1Size, DL, TLI, NullIsValidLocation) ||
-         isObjectSize(O2, V2Size, DL, TLI, NullIsValidLocation)))
+        (isObjectSize(O1, V1Size.getValue(), DL, TLI, NullIsValidLocation) ||
+         isObjectSize(O2, V2Size.getValue(), DL, TLI, NullIsValidLocation)))
       return AliasCache[Locs] = PartialAlias;
 
   // Recurse back into the best AA results we have, potentially with refined
   // memory locations. We have already ensured that BasicAA has a MayAlias
   // cache result for these, so any recursion back into BasicAA won't loop.
   AliasResult Result = getBestAAResults().alias(Locs.first, Locs.second);
   return AliasCache[Locs] = Result;
 }
for (unsigned i = 0, e = Src.size(); i != e; ++i) {
     if (Scale) {
       VariableGEPIndex Entry = {V, ZExtBits, SExtBits, -Scale};
       Dest.push_back(Entry);
     }
   }
 }
 
 bool BasicAAResult::constantOffsetHeuristic(
-    const SmallVectorImpl<VariableGEPIndex> &VarIndices, LocationSize V1Size,
-    LocationSize V2Size, int64_t BaseOffset, AssumptionCache *AC,
-    DominatorTree *DT) {
-  if (VarIndices.size() != 2 || V1Size == MemoryLocation::UnknownSize ||
-      V2Size == MemoryLocation::UnknownSize)
+    const SmallVectorImpl<VariableGEPIndex> &VarIndices,
+    LocationSize MaybeV1Size, LocationSize MaybeV2Size, int64_t BaseOffset,
+    AssumptionCache *AC, DominatorTree *DT) {
+  if (VarIndices.size() != 2 || MaybeV1Size == MemoryLocation::UnknownSize ||
+      MaybeV2Size == MemoryLocation::UnknownSize)
     return false;
 
+  const uint64_t V1Size = MaybeV1Size.getValue();
+  const uint64_t V2Size = MaybeV2Size.getValue();
+
   const VariableGEPIndex &Var0 = VarIndices[0], &Var1 = VarIndices[1];
 
   if (Var0.ZExtBits != Var1.ZExtBits || Var0.SExtBits != Var1.SExtBits ||
       Var0.Scale != -Var1.Scale)
     return false;
 
   unsigned Width = Var1.V->getType()->getIntegerBitWidth();
 

lib/Analysis/CFLAndersAliasAnalysis.cpp

CFLAndersAAResult::FunctionInfo::getAttrs(const Value *V) const {
   assert(V != nullptr);
 
   auto Itr = AttrMap.find(V);
   if (Itr != AttrMap.end())
     return Itr->second;
   return None;
 }
 
-bool CFLAndersAAResult::FunctionInfo::mayAlias(const Value *LHS,
-                                               LocationSize LHSSize,
-                                               const Value *RHS,
-                                               LocationSize RHSSize) const {
+bool CFLAndersAAResult::FunctionInfo::mayAlias(
+    const Value *LHS, LocationSize MaybeLHSSize, const Value *RHS,
+    LocationSize MaybeRHSSize) const {
   assert(LHS && RHS);
 
   // Check if we've seen LHS and RHS before. Sometimes LHS or RHS can be created
   // after the analysis gets executed, and we want to be conservative in those
   // cases.
   auto MaybeAttrsA = getAttrs(LHS);
   auto MaybeAttrsB = getAttrs(RHS);
   if (!MaybeAttrsA || !MaybeAttrsB)

 #ifdef EXPENSIVE_CHECKS
     assert(std::is_sorted(Itr->second.begin(), Itr->second.end(), Comparator));
 #endif
     auto RangePair = std::equal_range(Itr->second.begin(), Itr->second.end(),
                                       OffsetValue{RHS, 0}, Comparator);
 
     if (RangePair.first != RangePair.second) {
       // Be conservative about UnknownSize
-      if (LHSSize == MemoryLocation::UnknownSize ||
-          RHSSize == MemoryLocation::UnknownSize)
+      if (MaybeLHSSize == MemoryLocation::UnknownSize ||
+          MaybeRHSSize == MemoryLocation::UnknownSize)
         return true;
 
+      const uint64_t LHSSize = MaybeLHSSize.getValue();
+      const uint64_t RHSSize = MaybeRHSSize.getValue();
+
       for (const auto &OVal : make_range(RangePair)) {
         // Be conservative about UnknownOffset
         if (OVal.Offset == UnknownOffset)
           return true;
 
         // We know that LHS aliases (RHS + OVal.Offset) if the control flow
         // reaches here. The may-alias query essentially becomes integer
         // range-overlap queries over two ranges [OVal.Offset, OVal.Offset +

lib/Analysis/MemoryLocation.cpp

 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/IntrinsicInst.h"
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/IR/Type.h"
 using namespace llvm;
 
+void LocationSize::print(raw_ostream &OS) const {
+  OS << "LocationSize::";
+  if (*this == unknown())
+    OS << "unknown";
+  else if (*this == mapEmpty())
+    OS << "mapEmpty";
+  else if (*this == mapTombstone())
+    OS << "mapTombstone";
+  else
+    OS << "precise(" << getValue() << ')';
+}
+
 MemoryLocation MemoryLocation::get(const LoadInst *LI) {
   AAMDNodes AATags;
   LI->getAAMetadata(AATags);
   const auto &DL = LI->getModule()->getDataLayout();
 
   return MemoryLocation(LI->getPointerOperand(),
                         DL.getTypeStoreSize(LI->getType()), AATags);
 }

lib/Analysis/ScalarEvolutionAliasAnalysis.cpp

AliasResult SCEVAAResult::alias(const MemoryLocation &LocA,
   if (AS == BS)
     return MustAlias;
 
   // If something is known about the difference between the two addresses,
   // see if it's enough to prove a NoAlias.
   if (SE.getEffectiveSCEVType(AS->getType()) ==
       SE.getEffectiveSCEVType(BS->getType())) {
     unsigned BitWidth = SE.getTypeSizeInBits(AS->getType());
-    APInt ASizeInt(BitWidth, LocA.Size);
-    APInt BSizeInt(BitWidth, LocB.Size);
+    APInt ASizeInt(BitWidth, LocA.Size.hasValue()
+                                 ? LocA.Size.getValue()
+                                 : MemoryLocation::UnknownSize);
+    APInt BSizeInt(BitWidth, LocB.Size.hasValue()
+                                 ? LocB.Size.getValue()
+                                 : MemoryLocation::UnknownSize);
 
     // Compute the difference between the two pointers.
     const SCEV *BA = SE.getMinusSCEV(BS, AS);
 
     // Test whether the difference is known to be great enough that memory of
     // the given sizes don't overlap. This assumes that ASizeInt and BSizeInt
     // are non-zero, which is special-cased above.
     if (ASizeInt.ule(SE.getUnsignedRange(BA).getUnsignedMin()) &&

lib/Transforms/Scalar/DeadStoreElimination.cpp

static OverwriteResult isOverwrite(const MemoryLocation &Later,
                                    InstOverlapIntervalsTy &IOL,
                                    AliasAnalysis &AA,
                                    const Function *F) {
   // If we don't know the sizes of either access, then we can't do a comparison.
   if (Later.Size == MemoryLocation::UnknownSize ||
       Earlier.Size == MemoryLocation::UnknownSize)
     return OW_Unknown;
 
+  const uint64_t LaterSize = Later.Size.getValue();
+  const uint64_t EarlierSize = Earlier.Size.getValue();
+
   const Value *P1 = Earlier.Ptr->stripPointerCasts();
   const Value *P2 = Later.Ptr->stripPointerCasts();
 
   // If the start pointers are the same, we just have to compare sizes to see if
   // the later store was larger than the earlier store.
   if (P1 == P2 || AA.isMustAlias(P1, P2)) {
     // Make sure that the Later size is >= the Earlier size.
-    if (Later.Size >= Earlier.Size)
+    if (LaterSize >= EarlierSize)
       return OW_Complete;
   }
 
   // Check to see if the later store is to the entire object (either a global,
   // an alloca, or a byval/inalloca argument).  If so, then it clearly
   // overwrites any other store to the same object.
   const Value *UO1 = GetUnderlyingObject(P1, DL),
               *UO2 = GetUnderlyingObject(P2, DL);
 
   // If we can't resolve the same pointers to the same object, then we can't
   // analyze them at all.
   if (UO1 != UO2)
     return OW_Unknown;
 
   // If the "Later" store is to a recognizable object, get its size.
   uint64_t ObjectSize = getPointerSize(UO2, DL, TLI, F);
   if (ObjectSize != MemoryLocation::UnknownSize)
-    if (ObjectSize == Later.Size && ObjectSize >= Earlier.Size)
+    if (ObjectSize == LaterSize && ObjectSize >= EarlierSize)
       return OW_Complete;
 
   // Okay, we have stores to two completely different pointers.  Try to
   // decompose the pointer into a "base + constant_offset" form.  If the base
   // pointers are equal, then we can reason about the two stores.
   EarlierOff = 0;
   LaterOff = 0;
   const Value *BP1 = GetPointerBaseWithConstantOffset(P1, EarlierOff, DL);
static OverwriteResult isOverwrite(const MemoryLocation &Later,
   // 2. The earlier store has an offset greater than the later offset, but which
   //    still lies completely within the later store.
   //
   //        |--earlier--|
   //    |-----  later  ------|
   //
   // We have to be careful here as *Off is signed while *.Size is unsigned.
   if (EarlierOff >= LaterOff &&
-      Later.Size >= Earlier.Size &&
-      uint64_t(EarlierOff - LaterOff) + Earlier.Size <= Later.Size)
+      LaterSize >= EarlierSize &&
+      uint64_t(EarlierOff - LaterOff) + EarlierSize <= LaterSize)
     return OW_Complete;
 
   // We may now overlap, although the overlap is not complete. There might also
   // be other incomplete overlaps, and together, they might cover the complete
   // earlier write.
   // Note: The correctness of this logic depends on the fact that this function
   // is not even called providing DepWrite when there are any intervening reads.
   if (EnablePartialOverwriteTracking &&
-      LaterOff < int64_t(EarlierOff + Earlier.Size) &&
-      int64_t(LaterOff + Later.Size) >= EarlierOff) {
+      LaterOff < int64_t(EarlierOff + EarlierSize) &&
+      int64_t(LaterOff + LaterSize) >= EarlierOff) {
 
     // Insert our part of the overlap into the map.
     auto &IM = IOL[DepWrite];
     LLVM_DEBUG(dbgs() << "DSE: Partial overwrite: Earlier [" << EarlierOff
-                      << ", " << int64_t(EarlierOff + Earlier.Size)
+                      << ", " << int64_t(EarlierOff + EarlierSize)
                       << ") Later [" << LaterOff << ", "
-                      << int64_t(LaterOff + Later.Size) << ")\n");
+                      << int64_t(LaterOff + LaterSize) << ")\n");
 
     // Make sure that we only insert non-overlapping intervals and combine
     // adjacent intervals. The intervals are stored in the map with the ending
     // offset as the key (in the half-open sense) and the starting offset as
     // the value.
-    int64_t LaterIntStart = LaterOff, LaterIntEnd = LaterOff + Later.Size;
+    int64_t LaterIntStart = LaterOff, LaterIntEnd = LaterOff + LaterSize;
 
     // Find any intervals ending at, or after, LaterIntStart which start
     // before LaterIntEnd.
     auto ILI = IM.lower_bound(LaterIntStart);
     if (ILI != IM.end() && ILI->second <= LaterIntEnd) {
       // This existing interval is overlapped with the current store somewhere
       // in [LaterIntStart, LaterIntEnd]. Merge them by erasing the existing
       // intervals and adjusting our start and end.
if (ILI != IM.end() && ILI->second <= LaterIntEnd) {
         ILI = IM.erase(ILI);
       }
     }
 
     IM[LaterIntEnd] = LaterIntStart;
 
     ILI = IM.begin();
     if (ILI->second <= EarlierOff &&
-        ILI->first >= int64_t(EarlierOff + Earlier.Size)) {
+        ILI->first >= int64_t(EarlierOff + EarlierSize)) {
       LLVM_DEBUG(dbgs() << "DSE: Full overwrite from partials: Earlier ["
                         << EarlierOff << ", "
-                        << int64_t(EarlierOff + Earlier.Size)
+                        << int64_t(EarlierOff + EarlierSize)
                         << ") Composite Later [" << ILI->second << ", "
                         << ILI->first << ")\n");
       ++NumCompletePartials;
       return OW_Complete;
     }
   }
 
   // Check for an earlier store which writes to all the memory locations that
   // the later store writes to.
   if (EnablePartialStoreMerging && LaterOff >= EarlierOff &&
-      int64_t(EarlierOff + Earlier.Size) > LaterOff &&
-      uint64_t(LaterOff - EarlierOff) + Later.Size <= Earlier.Size) {
+      int64_t(EarlierOff + EarlierSize) > LaterOff &&
+      uint64_t(LaterOff - EarlierOff) + LaterSize <= EarlierSize) {
     LLVM_DEBUG(dbgs() << "DSE: Partial overwrite an earlier load ["
                       << EarlierOff << ", "
-                      << int64_t(EarlierOff + Earlier.Size)
+                      << int64_t(EarlierOff + EarlierSize)
                       << ") by a later store [" << LaterOff << ", "
-                      << int64_t(LaterOff + Later.Size) << ")\n");
+                      << int64_t(LaterOff + LaterSize) << ")\n");
     // TODO: Maybe come up with a better name?
     return OW_PartialEarlierWithFullLater;
   }
 
   // Another interesting case is if the later store overwrites the end of the
   // earlier store.
   //
   //      |--earlier--|
   //                |--   later   --|
   //
   // In this case we may want to trim the size of earlier to avoid generating
   // writes to addresses which will definitely be overwritten later
   if (!EnablePartialOverwriteTracking &&
-      (LaterOff > EarlierOff && LaterOff < int64_t(EarlierOff + Earlier.Size) &&
-       int64_t(LaterOff + Later.Size) >= int64_t(EarlierOff + Earlier.Size)))
+      (LaterOff > EarlierOff && LaterOff < int64_t(EarlierOff + EarlierSize) &&
+       int64_t(LaterOff + LaterSize) >= int64_t(EarlierOff + EarlierSize)))
     return OW_End;
 
   // Finally, we also need to check if the later store overwrites the beginning
   // of the earlier store.
   //
   //                |--earlier--|
   //      |--   later   --|
   //
   // In this case we may want to move the destination address and trim the size
   // of earlier to avoid generating writes to addresses which will definitely
   // be overwritten later.
   if (!EnablePartialOverwriteTracking &&
-      (LaterOff <= EarlierOff && int64_t(LaterOff + Later.Size) > EarlierOff)) {
-    assert(int64_t(LaterOff + Later.Size) <
-               int64_t(EarlierOff + Earlier.Size) &&
+      (LaterOff <= EarlierOff && int64_t(LaterOff + LaterSize) > EarlierOff)) {
+    assert(int64_t(LaterOff + LaterSize) < int64_t(EarlierOff + EarlierSize) &&
            "Expect to be handled as OW_Complete");
     return OW_Begin;
   }
   // Otherwise, they don't completely overlap.
   return OW_Unknown;
 }
 
 /// If 'Inst' might be a self read (i.e. a noop copy of a

 static bool removePartiallyOverlappedStores(AliasAnalysis *AA,
                                             const DataLayout &DL,
                                             InstOverlapIntervalsTy &IOL) {
   bool Changed = false;
   for (auto OI : IOL) {
     Instruction *EarlierWrite = OI.first;
     MemoryLocation Loc = getLocForWrite(EarlierWrite);
     assert(isRemovable(EarlierWrite) && "Expect only removable instruction");
-    assert(Loc.Size != MemoryLocation::UnknownSize && "Unexpected mem loc");
 
     const Value *Ptr = Loc.Ptr->stripPointerCasts();
     int64_t EarlierStart = 0;
-    int64_t EarlierSize = int64_t(Loc.Size);
+    int64_t EarlierSize = int64_t(Loc.Size.getValue());
     GetPointerBaseWithConstantOffset(Ptr, EarlierStart, DL);
     OverlapIntervalsTy &IntervalMap = OI.second;
     Changed |=
         tryToShortenEnd(EarlierWrite, IntervalMap, EarlierStart, EarlierSize);
     if (IntervalMap.empty())
       continue;
     Changed |=
         tryToShortenBegin(EarlierWrite, IntervalMap, EarlierStart, EarlierSize);
while (InstDep.isDef() || InstDep.isClobber()) {
           InstDep = MD->getDependency(Inst);
           continue;
         } else if ((OR == OW_End && isShortenableAtTheEnd(DepWrite)) ||
                    ((OR == OW_Begin &&
                      isShortenableAtTheBeginning(DepWrite)))) {
           assert(!EnablePartialOverwriteTracking && "Do not expect to perform "
                                                     "when partial-overwrite "
                                                     "tracking is enabled");
-          int64_t EarlierSize = DepLoc.Size;
-          int64_t LaterSize = Loc.Size;
+          // The overwrite result is known, so these must be known, too.
+          int64_t EarlierSize = DepLoc.Size.getValue();
+          int64_t LaterSize = Loc.Size.getValue();
           bool IsOverwriteEnd = (OR == OW_End);
           MadeChange |= tryToShorten(DepWrite, DepWriteOffset, EarlierSize,
                                     InstWriteOffset, LaterSize, IsOverwriteEnd);
         } else if (EnablePartialStoreMerging &&
                    OR == OW_PartialEarlierWithFullLater) {
           auto *Earlier = dyn_cast<StoreInst>(DepWrite);
           auto *Later = dyn_cast<StoreInst>(Inst);
           if (Earlier && isa<ConstantInt>(Earlier->getValueOperand()) &&

test/Analysis/AliasSet/argmemonly.ll

 ; RUN: opt -basicaa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
 
 @s = global i8 1, align 1
 @d = global i8 2, align 1
 
 ; CHECK: Alias sets for function 'test_alloca_argmemonly':
 ; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref    Pointers: (i8* %d, unknown), (i8* %s, unknown)   
 define void @test_alloca_argmemonly(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @my_memcpy(i8* %d, i8* %s, i64 1)
   ret void
 }
 
 ; CHECK: Alias sets for function 'test_readonly_arg'
 ; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 2 pointer values.
 ; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, unknown)
 ; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %s, unknown)
 define i8 @test_readonly_arg(i8* noalias %s, i8* noalias %d) {
 entry:
   call void @my_memcpy(i8* %d, i8* %s, i64 1)
   %ret = load i8, i8* %s
   ret i8 %ret
 }
 
 ; CHECK: Alias sets for function 'test_noalias_argmemonly':
 ; CHECK-NEXT: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref    Pointers: (i8* %d, unknown), (i8* %s, unknown)   
 define void @test_noalias_argmemonly(i8* noalias %a, i8* %s, i8* %d) {
 entry:
   store i8 1, i8* %a, align 1
   call void @my_memmove(i8* %d, i8* %s, i64 1)
   ret void
 }
 

 
 declare void @my_memset(i8* nocapture writeonly, i8, i64) argmemonly
 declare void @my_memcpy(i8* nocapture writeonly, i8* nocapture readonly, i64) argmemonly
 declare void @my_memmove(i8* nocapture, i8* nocapture readonly, i64) argmemonly
 
 
 ; CHECK: Alias sets for function 'test_attribute_intersect':
 ; CHECK-NEXT: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK-NEXT: AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define i8 @test_attribute_intersect(i8* noalias %a) {
 entry:
   ;; This call is effectively readnone since the argument is readonly
   ;; and the function is declared writeonly.  
   call void @attribute_intersect(i8* %a)
   %val = load i8, i8* %a
   ret i8 %val
 }
 
 declare void @attribute_intersect(i8* readonly) argmemonly writeonly
 

test/Analysis/AliasSet/guards.ll

 ; RUN: opt -basicaa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
 declare void @llvm.experimental.guard(i1, ...)
 
 ; CHECK: Alias sets for function 'test0':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test0(i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test1':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test1(i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test2':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test2(i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test3':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test3(i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test4':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test4(i1 %cond_a) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test5':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test5(i1 %cond_a) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test6':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test6(i1 %cond_a) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test7':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test7(i1 %cond_a) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test8':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test8(i1 %cond_a, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test9':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test9(i1 %cond_a, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test10':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test10(i1 %cond_a, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test11':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test11(i1 %cond_a, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test12':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test12(i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test13':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test13(i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test14':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test14(i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test15':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test15(i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test16':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test16(i1 %cond_a, i8* %b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test17':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test17(i1 %cond_a, i8* %b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test18':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test18(i1 %cond_a, i8* %b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test19':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test19(i1 %cond_a, i8* %b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test20':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test20(i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test21':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test21(i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test22':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test22(i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test23':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test23(i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test24':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test24(i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test25':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test25(i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test26':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test26(i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test27':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test27(i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test28':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test28(i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test29':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test29(i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test30':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test30(i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test31':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test31(i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test32':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test32(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test33':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test33(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test34':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test34(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test35':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 define void @test35(i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = alloca i8, align 1
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test36':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test36(i8* %a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test37':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test37(i8* %a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test38':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test38(i8* %a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test39':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test39(i8* %a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test40':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test40(i8* %a, i1 %cond_a) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test41':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test41(i8* %a, i1 %cond_a) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test42':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test42(i8* %a, i1 %cond_a) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test43':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test43(i8* %a, i1 %cond_a) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test44':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test44(i8* %a, i1 %cond_a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test45':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test45(i8* %a, i1 %cond_a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test46':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test46(i8* %a, i1 %cond_a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test47':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test47(i8* %a, i1 %cond_a, i1 %cond_b) {
 entry:
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test48':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test48(i8* %a, i8* %b, i1 %cond_b) {
 entry:
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test49':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test49(i8* %a, i8* %b, i1 %cond_b) {
 entry:
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test50':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test50(i8* %a, i8* %b, i1 %cond_b) {
 entry:
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test51':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test51(i8* %a, i8* %b, i1 %cond_b) {
 entry:
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test52':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test52(i8* %a, i1 %cond_a, i8* %b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test53':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test53(i8* %a, i1 %cond_a, i8* %b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test54':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test54(i8* %a, i1 %cond_a, i8* %b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test55':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test55(i8* %a, i1 %cond_a, i8* %b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test56':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test56(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test57':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test57(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test58':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test58(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test59':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test59(i8* %a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test60':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test60(i8* %a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test61':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test61(i8* %a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test62':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test62(i8* %a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test63':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test63(i8* %a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test64':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test64(i8* %a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test65':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test65(i8* %a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test66':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test66(i8* %a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test67':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test67(i8* %a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test68':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test68(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test69':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test69(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test70':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test70(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test71':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test71(i8* %a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test72':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test72(i8** %ptr_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test73':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test73(i8** %ptr_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test74':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test74(i8** %ptr_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test75':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test75(i8** %ptr_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test76':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test76(i8** %ptr_a, i1 %cond_a) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test77':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test77(i8** %ptr_a, i1 %cond_a) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test78':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test78(i8** %ptr_a, i1 %cond_a) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test79':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test79(i8** %ptr_a, i1 %cond_a) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test80':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test80(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test81':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test81(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test82':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test82(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test83':
 ; CHECK: Alias Set Tracker: 2 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test83(i8** %ptr_a, i1 %cond_a, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = alloca i8, align 1
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test84':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test84(i8** %ptr_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test85':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test85(i8** %ptr_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test86':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test86(i8** %ptr_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test87':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test87(i8** %ptr_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test88':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test88(i8** %ptr_a, i1 %cond_a, i8* %b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test89':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test89(i8** %ptr_a, i1 %cond_a, i8* %b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test90':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test90(i8** %ptr_a, i1 %cond_a, i8* %b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test91':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test91(i8** %ptr_a, i1 %cond_a, i8* %b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test92':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test92(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test93':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test93(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test94':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test94(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test95':
 ; CHECK: Alias Set Tracker: 1 alias sets for 3 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 4] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test95(i8** %ptr_a, i1 %cond_a, i8* %b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test96':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test96(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test97':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test97(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test98':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test98(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test99':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test99(i8** %ptr_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test100':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test100(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test101':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test101(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test102':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test102(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test103':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
 define void @test103(i8** %ptr_a, i1 %cond_a, i8** %ptr_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test104':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref       Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Ref       Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test104(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %1 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test105':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test105(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   %0 = load i8, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test106':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test106(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   %0 = load i8, i8* %b
   ret void
 }
 
 ; CHECK: Alias sets for function 'test107':
 ; CHECK: Alias Set Tracker: 1 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, 8), (i8** %ptr_b, 8), (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 5] may alias, Mod/Ref   Pointers: (i8** %ptr_a, LocationSize::precise(8)), (i8** %ptr_b, LocationSize::precise(8)), (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     2 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ],   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
 define void @test107(i8** %ptr_a, i1 %cond_a, i8** %ptr_b, i1 %cond_b) {
 entry:
   %a = load i8*, i8** %ptr_a
   %b = load i8*, i8** %ptr_b
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_a) [ "deopt"() ]
   store i8 0, i8* %a
   call void (i1, ...) @llvm.experimental.guard(i1 %cond_b) [ "deopt"() ]
   store i8 1, i8* %b
   ret void
 }

test/Analysis/AliasSet/intrinsics.ll

 ; RUN: opt -basicaa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
 
 ; CHECK: Alias sets for function 'test1':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT: 1 Unknown instruction
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test1(i32 %c) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   %cond1 = icmp ne i32 %c, 0
   call void @llvm.assume(i1 %cond1)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test2':
 ; CHECK: Alias Set Tracker: 3 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] may alias, Ref
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test2(i32 %c) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   %cond1 = icmp ne i32 %c, 0
   call void (i1, ...) @llvm.experimental.guard(i1 %cond1)["deopt"()]
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test3':
 ; CHECK: Alias Set Tracker: 1 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, 1), (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 3] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1)), (i8* %b, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ]
 define void @test3(i32 %c, i8* %a, i8* %b) {
 entry:
   store i8 1, i8* %a, align 1
   %cond1 = icmp ne i32 %c, 0
   call void (i1, ...) @llvm.experimental.guard(i1 %cond1)["deopt"()]
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test4':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK:     1 Unknown instructions:   call void (i1, ...) @llvm.experimental.guard(i1 %cond1) [ "deopt"() ]
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test4(i32 %c, i8* %a) {
 entry:
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   %cond1 = icmp ne i32 %c, 0
   call void (i1, ...) @llvm.experimental.guard(i1 %cond1)["deopt"()]
   store i8 1, i8* %b, align 1
   ret void
 }
 
 declare void @llvm.assume(i1)
 declare void @llvm.experimental.guard(i1, ...)

test/Analysis/AliasSet/memset.ll

 ; RUN: opt -basicaa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
 
 @s = global i8 1, align 1
 @d = global i8 2, align 1
 
 ; CHECK: Alias sets for function 'test_known_size':
 ; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, LocationSize::precise(1))
 define void @test_known_size(i8* noalias %d) {
 entry:
   call void @llvm.memset.p0i8.i64(i8* align 1 %d, i8 0, i64 1, i1 false)
   ret void
 }
 
 ; CHECK: Alias sets for function 'test_unknown_size':
 ; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, unknown)
 define void @test_unknown_size(i8* noalias %d, i64 %len) {
 entry:
   call void @llvm.memset.p0i8.i64(i8* align 1 %d, i8 0, i64 %len, i1 false)
   ret void
 }
 
 
 ; CHECK: Alias sets for function 'test_atomic_known_size':
 ; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, LocationSize::precise(1))
 define void @test_atomic_known_size(i8* noalias %d) {
 entry:
   call void @llvm.memset.element.unordered.atomic.p0i8.i32(i8* align 1 %d, i8 0, i64 1, i32 1)
   ret void
 }
 
 ; CHECK: Alias sets for function 'test_atomic_unknown_size':
 ; CHECK: Alias Set Tracker: 1 alias sets for 1 pointer values.

test/Analysis/AliasSet/memtransfer.ll

 ; RUN: opt -basicaa -print-alias-sets -S -o - < %s 2>&1 | FileCheck %s
 
 @s = global i8 1, align 1
 @d = global i8 2, align 1
 
 
 ; CHECK: Alias sets for function 'test_known_size':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %s, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %s, LocationSize::precise(1))
 define void @test_known_size(i8* noalias %s, i8* noalias %d) {
 entry:
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 false)
   ret void
 }
 
 ; CHECK: Alias sets for function 'test_unknown_size':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %d, unknown)
 ; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Ref       Pointers: (i8* %s, unknown)
 define void @test_unknown_size(i8* noalias %s, i8* noalias %d, i64 %len) {
 entry:
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 %len, i1 false)
   ret void
 }
 
 
 ; CHECK: Alias sets for function 'test1':
 ; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT:    1 Unknown instructions
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, 1), (i8* %s, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test1(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 false)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test1_atomic':
 ; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT:    1 Unknown instructions
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, 1), (i8* %s, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test1_atomic(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store atomic i8 1, i8* %a unordered, align 1
   call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %d, i8* align 1 %s, i64 1, i32 1)
   store atomic i8 1, i8* %b unordered, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test2':
 ; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT:    1 Unknown instructions
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref    Pointers: (i8* %d, 1), (i8* %s, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref    Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test2(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 true)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test3':
 ; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT:    1 Unknown instructions
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, 1), (i8* %s, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test3(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 false)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test3_atomic':
 ; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT:    1 Unknown instructions
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, 1), (i8* %s, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref   Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test3_atomic(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store atomic i8 1, i8* %a unordered, align 1
   call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %d, i8* align 1 %s, i64 1, i32 1)
   store atomic i8 1, i8* %b unordered, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test4':
 ; CHECK: Alias Set Tracker: 3 alias sets for 4 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %a, LocationSize::precise(1))
 ; CHECK-NOT:    1 Unknown instructions
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref    Pointers: (i8* %d, 1), (i8* %s, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 2] may alias, Mod/Ref    Pointers: (i8* %d, LocationSize::precise(1)), (i8* %s, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test4(i8* %s, i8* %d) {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %d, i8* %s, i64 1, i1 true)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test5':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test5() {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i1 false)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test5_atomic':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test5_atomic() {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store atomic i8 1, i8* %a unordered, align 1
   call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 1, i32 1)
   store atomic i8 1, i8* %b unordered, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test6':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test6() {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memmove.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i1 false)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test6_atomic':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod       Pointers: (i8* %b, LocationSize::precise(1))
 define void @test6_atomic() {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store atomic i8 1, i8* %a unordered, align 1
   call void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 1, i32 1)
   store atomic i8 1, i8* %b unordered, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test7':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 define void @test7() {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store i8 1, i8* %a, align 1
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %b, i8* %a, i64 1, i1 false)
   call void @llvm.memcpy.p0i8.p0i8.i64(i8* %a, i8* %b, i64 1, i1 false)
   store i8 1, i8* %b, align 1
   ret void
 }
 
 ; CHECK: Alias sets for function 'test7_atomic':
 ; CHECK: Alias Set Tracker: 2 alias sets for 2 pointer values.
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, 1)
-; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %b, 1)
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %a, LocationSize::precise(1))
+; CHECK:   AliasSet[0x{{[0-9a-f]+}}, 1] must alias, Mod/Ref   Pointers: (i8* %b, LocationSize::precise(1))
 define void @test7_atomic() {
 entry:
   %a = alloca i8, align 1
   %b = alloca i8, align 1
   store atomic i8 1, i8* %a unordered, align 1
   call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %b, i8* align 1 %a, i64 1, i32 1)
   call void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* align 1 %a, i8* align 1 %b, i64 1, i32 1)
   store atomic i8 1, i8* %b unordered, align 1
   ret void
 }
 
 declare void @llvm.memcpy.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i1)
 declare void @llvm.memcpy.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32)
 declare void @llvm.memmove.p0i8.p0i8.i64(i8* nocapture, i8* nocapture readonly, i64, i1)
 declare void @llvm.memmove.element.unordered.atomic.p0i8.p0i8.i64(i8* nocapture writeonly, i8* nocapture readonly, i64, i32)

test/Analysis/AliasSet/saturation.ll

 ; RUN: opt -basicaa -print-alias-sets -alias-set-saturation-threshold=2 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=NOSAT
 ; RUN: opt -basicaa -print-alias-sets -alias-set-saturation-threshold=1 -S -o - < %s 2>&1 | FileCheck %s --check-prefix=CHECK --check-prefix=SAT
 
 ; CHECK-LABEL: 'allmust'
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, 4)
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, 4)
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %c, 4)
-; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %d, 4)
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %c, LocationSize::precise(4))
+; CHECK: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %d, LocationSize::precise(4))
 define void @allmust() {
   %a = alloca i32
   %b = alloca i32
   %c = alloca i32
   %d = alloca i32
   store i32 1, i32* %a
   store i32 2, i32* %b
   store i32 3, i32* %c
   store i32 4, i32* %d
   ret void
 }
 
 ; CHECK-LABEL :'mergemay'
-; NOSAT: AliasSet[{{.*}}, 2] may alias, Mod Pointers: (i32* %a, 4), (i32* %a1, 4)
-; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, 4)
+; NOSAT: AliasSet[{{.*}}, 2] may alias, Mod Pointers: (i32* %a, LocationSize::precise(4)), (i32* %a1, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
 ; SAT: AliasSet[{{.*}}, 2] may alias, Mod forwarding to 0x[[FWD:[0-9a-f]*]]
 ; SAT: AliasSet[{{.*}}, 1] must alias, Mod forwarding to 0x[[FWD]]
-; SAT: AliasSet[0x[[FWD]], 2] may alias, Mod/Ref Pointers: (i32* %a, 4), (i32* %a1, 4), (i32* %b, 4)
+; SAT: AliasSet[0x[[FWD]], 2] may alias, Mod/Ref Pointers: (i32* %a, LocationSize::precise(4)), (i32* %a1, LocationSize::precise(4)), (i32* %b, LocationSize::precise(4))
 define void @mergemay(i32 %k) {
   %a = alloca i32
   %b = alloca i32
   store i32 1, i32* %a
   store i32 2, i32* %b
   %a1 = getelementptr i32, i32 *%a, i32 %k
   store i32 2, i32* %a1  
   ret void
 }
 
 ; CHECK-LABEL: 'mergemust'
-; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, 4)
-; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, 4)
-; NOSAT: AliasSet[{{.*}}, 2] may alias,  Mod Pointers: (i32* %c, 4), (i32* %d, 4)
+; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %a, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 1] must alias, Mod Pointers: (i32* %b, LocationSize::precise(4))
+; NOSAT: AliasSet[{{.*}}, 2] may alias,  Mod Pointers: (i32* %c, LocationSize::precise(4)), (i32* %d, LocationSize::precise(4))
 ; SAT: AliasSet[{{.*}}, 1] must alias, Mod forwarding to 0x[[FWD:[0-9a-f]*]]
 ; SAT: AliasSet[{{.*}}, 1] must alias, Mod forwarding to 0x[[FWD]]
 ; SAT: AliasSet[{{.*}}, 2] may alias,  Mod forwarding to 0x[[FWD]]
-; SAT: AliasSet[0x[[FWD]], 3] may alias, Mod/Ref Pointers: (i32* %a, 4), (i32* %b, 4), (i32* %c, 4), (i32* %d, 4)
+; SAT: AliasSet[0x[[FWD]], 3] may alias, Mod/Ref Pointers: (i32* %a, LocationSize::precise(4)), (i32* %b, LocationSize::precise(4)), (i32* %c, LocationSize::precise(4)), (i32* %d, LocationSize::precise(4))
 define void @mergemust(i32* %c, i32* %d) {
   %a = alloca i32
   %b = alloca i32
   store i32 1, i32* %a
   store i32 2, i32* %b
   store i32 3, i32* %c
   store i32 4, i32* %d
   ret void
 }