Index: include/llvm/Analysis/MemoryLocation.h =================================================================== --- include/llvm/Analysis/MemoryLocation.h +++ include/llvm/Analysis/MemoryLocation.h @@ -34,8 +34,80 @@ class TargetLibraryInfo; // Represents the size of a MemoryLocation. Logically, it's an -// Optional, with a special UnknownSize value from `MemoryLocation`. -using LocationSize = uint64_t; +// Optional. +// +// 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. /// @@ -143,13 +215,30 @@ } }; -// Specialize DenseMapInfo for MemoryLocation. +// Specialize DenseMapInfo. +template <> struct DenseMapInfo { + static inline LocationSize getEmptyKey() { + return LocationSize::mapEmpty(); + } + static inline LocationSize getTombstoneKey() { + return LocationSize::mapTombstone(); + } + static unsigned getHashValue(const LocationSize &Val) { + return DenseMapInfo::getHashValue(Val.toRaw()); + } + static bool isEqual(const LocationSize &LHS, const LocationSize &RHS) { + return LHS == RHS; + } +}; + template <> struct DenseMapInfo { static inline MemoryLocation getEmptyKey() { - return MemoryLocation(DenseMapInfo::getEmptyKey(), 0); + return MemoryLocation(DenseMapInfo::getEmptyKey(), + DenseMapInfo::getEmptyKey()); } static inline MemoryLocation getTombstoneKey() { - return MemoryLocation(DenseMapInfo::getTombstoneKey(), 0); + return MemoryLocation(DenseMapInfo::getTombstoneKey(), + DenseMapInfo::getTombstoneKey()); } static unsigned getHashValue(const MemoryLocation &Val) { return DenseMapInfo::getHashValue(Val.Ptr) ^ Index: lib/Analysis/BasicAliasAnalysis.cpp =================================================================== --- lib/Analysis/BasicAliasAnalysis.cpp +++ lib/Analysis/BasicAliasAnalysis.cpp @@ -1001,9 +1001,9 @@ /// 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() && @@ -1019,10 +1019,13 @@ // 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(GEP1->getOperand(GEP1->getNumOperands() - 1)); ConstantInt *C2 = @@ -1179,11 +1182,14 @@ // 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. @@ -1346,7 +1352,7 @@ 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; } @@ -1361,7 +1367,7 @@ // stripped a gep with negative index ('gep , -1, ...). if (V1Size != MemoryLocation::UnknownSize && V2Size != MemoryLocation::UnknownSize) { - if (-(uint64_t)GEP1BaseOffset < V1Size) + if (-(uint64_t)GEP1BaseOffset < V1Size.getValue()) return PartialAlias; return NoAlias; } @@ -1411,14 +1417,17 @@ // 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, @@ -1707,9 +1716,11 @@ // 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 @@ -1769,8 +1780,8 @@ 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 @@ -1853,13 +1864,16 @@ } bool BasicAAResult::constantOffsetHeuristic( - const SmallVectorImpl &VarIndices, LocationSize V1Size, - LocationSize V2Size, int64_t BaseOffset, AssumptionCache *AC, - DominatorTree *DT) { - if (VarIndices.size() != 2 || V1Size == MemoryLocation::UnknownSize || - V2Size == MemoryLocation::UnknownSize) + const SmallVectorImpl &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 || Index: lib/Analysis/CFLAndersAliasAnalysis.cpp =================================================================== --- lib/Analysis/CFLAndersAliasAnalysis.cpp +++ lib/Analysis/CFLAndersAliasAnalysis.cpp @@ -515,10 +515,9 @@ 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 @@ -558,10 +557,13 @@ 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) Index: lib/Analysis/MemoryLocation.cpp =================================================================== --- lib/Analysis/MemoryLocation.cpp +++ lib/Analysis/MemoryLocation.cpp @@ -18,6 +18,18 @@ #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); Index: lib/Analysis/ScalarEvolutionAliasAnalysis.cpp =================================================================== --- lib/Analysis/ScalarEvolutionAliasAnalysis.cpp +++ lib/Analysis/ScalarEvolutionAliasAnalysis.cpp @@ -43,8 +43,12 @@ 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); Index: lib/Transforms/Scalar/DeadStoreElimination.cpp =================================================================== --- lib/Transforms/Scalar/DeadStoreElimination.cpp +++ lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -354,6 +354,9 @@ 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(); @@ -361,7 +364,7 @@ // 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; } @@ -379,7 +382,7 @@ // 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 @@ -410,8 +413,8 @@ // // 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 @@ -420,21 +423,21 @@ // 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. @@ -464,10 +467,10 @@ 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; @@ -478,13 +481,13 @@ // 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; } @@ -498,8 +501,8 @@ // 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 @@ -512,9 +515,8 @@ // 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; } @@ -1002,11 +1004,10 @@ 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 |= @@ -1203,8 +1204,9 @@ 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); Index: test/Analysis/AliasSet/argmemonly.ll =================================================================== --- test/Analysis/AliasSet/argmemonly.ll +++ test/Analysis/AliasSet/argmemonly.ll @@ -5,7 +5,7 @@ ; 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: @@ -28,7 +28,7 @@ ; 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: @@ -121,7 +121,7 @@ ; 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 Index: test/Analysis/AliasSet/guards.ll =================================================================== --- test/Analysis/AliasSet/guards.ll +++ test/Analysis/AliasSet/guards.ll @@ -3,10 +3,10 @@ ; 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 @@ -19,10 +19,10 @@ ; 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 @@ -35,10 +35,10 @@ ; 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 @@ -51,10 +51,10 @@ ; 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 @@ -69,8 +69,8 @@ ; 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 @@ -85,8 +85,8 @@ ; 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 @@ -101,8 +101,8 @@ ; 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 @@ -117,8 +117,8 @@ ; 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 @@ -133,8 +133,8 @@ ; 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 @@ -150,8 +150,8 @@ ; 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 @@ -167,8 +167,8 @@ ; 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 @@ -184,8 +184,8 @@ ; 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 @@ -199,8 +199,8 @@ ; 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: @@ -213,8 +213,8 @@ ; 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: @@ -227,8 +227,8 @@ ; 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: @@ -241,8 +241,8 @@ ; 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: @@ -255,9 +255,9 @@ ; 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 @@ -269,9 +269,9 @@ ; 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 @@ -283,9 +283,9 @@ ; 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 @@ -297,9 +297,9 @@ ; 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 @@ -311,9 +311,9 @@ ; 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 @@ -326,9 +326,9 @@ ; 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 @@ -341,9 +341,9 @@ ; 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 @@ -356,9 +356,9 @@ ; 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 @@ -371,9 +371,9 @@ ; 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 @@ -386,9 +386,9 @@ ; 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 @@ -401,9 +401,9 @@ ; 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 @@ -416,9 +416,9 @@ ; 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 @@ -431,9 +431,9 @@ ; 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 @@ -446,9 +446,9 @@ ; 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 @@ -461,9 +461,9 @@ ; 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 @@ -476,9 +476,9 @@ ; 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 @@ -491,9 +491,9 @@ ; 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 @@ -507,9 +507,9 @@ ; 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 @@ -523,9 +523,9 @@ ; 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 @@ -539,9 +539,9 @@ ; 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 @@ -555,9 +555,9 @@ ; 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 @@ -569,9 +569,9 @@ ; 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 @@ -583,9 +583,9 @@ ; 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 @@ -597,9 +597,9 @@ ; 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 @@ -611,9 +611,9 @@ ; 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 @@ -625,9 +625,9 @@ ; 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 @@ -639,9 +639,9 @@ ; 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 @@ -653,9 +653,9 @@ ; 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 @@ -667,9 +667,9 @@ ; 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 @@ -682,9 +682,9 @@ ; 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 @@ -697,9 +697,9 @@ ; 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 @@ -712,9 +712,9 @@ ; 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 @@ -727,7 +727,7 @@ ; 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: @@ -739,7 +739,7 @@ ; 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: @@ -751,7 +751,7 @@ ; 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: @@ -763,7 +763,7 @@ ; 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: @@ -775,7 +775,7 @@ ; 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: @@ -787,7 +787,7 @@ ; 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: @@ -799,7 +799,7 @@ ; 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: @@ -811,7 +811,7 @@ ; 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: @@ -823,7 +823,7 @@ ; 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: @@ -836,7 +836,7 @@ ; 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: @@ -849,7 +849,7 @@ ; 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: @@ -862,7 +862,7 @@ ; 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: @@ -875,7 +875,7 @@ ; 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: @@ -888,7 +888,7 @@ ; 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: @@ -901,7 +901,7 @@ ; 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: @@ -914,7 +914,7 @@ ; 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: @@ -927,7 +927,7 @@ ; 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: @@ -940,7 +940,7 @@ ; 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: @@ -953,7 +953,7 @@ ; 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: @@ -966,7 +966,7 @@ ; 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: @@ -979,7 +979,7 @@ ; 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: @@ -993,7 +993,7 @@ ; 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: @@ -1007,7 +1007,7 @@ ; 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: @@ -1021,7 +1021,7 @@ ; 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: @@ -1035,9 +1035,9 @@ ; 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 @@ -1050,9 +1050,9 @@ ; 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 @@ -1065,9 +1065,9 @@ ; 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 @@ -1080,9 +1080,9 @@ ; 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 @@ -1095,9 +1095,9 @@ ; 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 @@ -1110,9 +1110,9 @@ ; 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 @@ -1125,9 +1125,9 @@ ; 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 @@ -1140,9 +1140,9 @@ ; 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 @@ -1155,9 +1155,9 @@ ; 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 @@ -1171,9 +1171,9 @@ ; 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 @@ -1187,9 +1187,9 @@ ; 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 @@ -1203,9 +1203,9 @@ ; 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 @@ -1219,7 +1219,7 @@ ; 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: @@ -1232,7 +1232,7 @@ ; 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: @@ -1245,7 +1245,7 @@ ; 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: @@ -1258,7 +1258,7 @@ ; 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: @@ -1271,7 +1271,7 @@ ; 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: @@ -1284,7 +1284,7 @@ ; 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: @@ -1297,7 +1297,7 @@ ; 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: @@ -1310,7 +1310,7 @@ ; 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: @@ -1323,7 +1323,7 @@ ; 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: @@ -1337,7 +1337,7 @@ ; 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: @@ -1351,7 +1351,7 @@ ; 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: @@ -1365,7 +1365,7 @@ ; 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: @@ -1379,7 +1379,7 @@ ; 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: @@ -1393,7 +1393,7 @@ ; 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: @@ -1407,7 +1407,7 @@ ; 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: @@ -1421,7 +1421,7 @@ ; 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: @@ -1435,7 +1435,7 @@ ; 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: @@ -1449,7 +1449,7 @@ ; 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: @@ -1463,7 +1463,7 @@ ; 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: @@ -1477,7 +1477,7 @@ ; 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: @@ -1491,7 +1491,7 @@ ; 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: @@ -1506,7 +1506,7 @@ ; 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: @@ -1521,7 +1521,7 @@ ; 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: @@ -1536,7 +1536,7 @@ ; 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: Index: test/Analysis/AliasSet/intrinsics.ll =================================================================== --- test/Analysis/AliasSet/intrinsics.ll +++ test/Analysis/AliasSet/intrinsics.ll @@ -2,9 +2,9 @@ ; 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 @@ -18,10 +18,10 @@ ; 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 @@ -35,7 +35,7 @@ ; 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: @@ -48,9 +48,9 @@ ; 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 Index: test/Analysis/AliasSet/memset.ll =================================================================== --- test/Analysis/AliasSet/memset.ll +++ test/Analysis/AliasSet/memset.ll @@ -5,7 +5,7 @@ ; 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) @@ -24,7 +24,7 @@ ; 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) Index: test/Analysis/AliasSet/memtransfer.ll =================================================================== --- test/Analysis/AliasSet/memtransfer.ll +++ test/Analysis/AliasSet/memtransfer.ll @@ -6,8 +6,8 @@ ; 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) @@ -27,10 +27,10 @@ ; 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 @@ -43,10 +43,10 @@ ; 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 @@ -59,10 +59,10 @@ ; 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 @@ -75,10 +75,10 @@ ; 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 @@ -91,10 +91,10 @@ ; 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 @@ -107,10 +107,10 @@ ; 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 @@ -123,8 +123,8 @@ ; 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 @@ -137,8 +137,8 @@ ; 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 @@ -151,8 +151,8 @@ ; 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 @@ -165,8 +165,8 @@ ; 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 @@ -179,8 +179,8 @@ ; 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 @@ -194,8 +194,8 @@ ; 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 Index: test/Analysis/AliasSet/saturation.ll =================================================================== --- test/Analysis/AliasSet/saturation.ll +++ test/Analysis/AliasSet/saturation.ll @@ -2,10 +2,10 @@ ; 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 @@ -19,11 +19,11 @@ } ; 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 @@ -35,13 +35,13 @@ } ; 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