[llvm] c1a88e0 - [AA][NFC] Convert AliasResult to class containing offset for PartialAlias case.
via llvm-commits
llvm-commits at lists.llvm.org
Fri Apr 9 03:26:21 PDT 2021
Author: dfukalov
Date: 2021-04-09T13:26:09+03:00
New Revision: c1a88e007b04d510fc6d3207ff5b2d80556d8f12
URL: https://github.com/llvm/llvm-project/commit/c1a88e007b04d510fc6d3207ff5b2d80556d8f12
DIFF: https://github.com/llvm/llvm-project/commit/c1a88e007b04d510fc6d3207ff5b2d80556d8f12.diff
LOG: [AA][NFC] Convert AliasResult to class containing offset for PartialAlias case.
Add an ability to store `Offset` between partially aliased location. Use this
storage within returned `ResultAlias` instead of caching it in `AAQueryInfo`.
Reviewed By: asbirlea
Differential Revision: https://reviews.llvm.org/D98718
Added:
Modified:
llvm/include/llvm/Analysis/AliasAnalysis.h
llvm/include/llvm/Analysis/AliasSetTracker.h
llvm/include/llvm/Analysis/MemorySSA.h
llvm/lib/Analysis/AliasAnalysis.cpp
llvm/lib/Analysis/BasicAliasAnalysis.cpp
llvm/lib/Analysis/MemorySSA.cpp
llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
llvm/unittests/Analysis/AliasAnalysisTest.cpp
llvm/unittests/Analysis/MemorySSATest.cpp
Removed:
################################################################################
diff --git a/llvm/include/llvm/Analysis/AliasAnalysis.h b/llvm/include/llvm/Analysis/AliasAnalysis.h
index f1506945273c..1341e78d8b49 100644
--- a/llvm/include/llvm/Analysis/AliasAnalysis.h
+++ b/llvm/include/llvm/Analysis/AliasAnalysis.h
@@ -78,21 +78,64 @@ class Value;
///
/// See docs/AliasAnalysis.html for more information on the specific meanings
/// of these values.
-enum AliasResult : uint8_t {
- /// The two locations do not alias at all.
- ///
- /// This value is arranged to convert to false, while all other values
- /// convert to true. This allows a boolean context to convert the result to
- /// a binary flag indicating whether there is the possibility of aliasing.
- NoAlias = 0,
- /// The two locations may or may not alias. This is the least precise result.
- MayAlias,
- /// The two locations alias, but only due to a partial overlap.
- PartialAlias,
- /// The two locations precisely alias each other.
- MustAlias,
+class AliasResult {
+private:
+ static const int OffsetBits = 23;
+ static const int AliasBits = 8;
+ static_assert(AliasBits + 1 + OffsetBits <= 32,
+ "AliasResult size is intended to be 4 bytes!");
+
+ unsigned int Alias : AliasBits;
+ unsigned int HasOffset : 1;
+ signed int Offset : OffsetBits;
+
+public:
+ enum Result : uint8_t {
+ /// The two locations do not alias at all.
+ ///
+ /// This value is arranged to convert to false, while all other values
+ /// convert to true. This allows a boolean context to convert the result to
+ /// a binary flag indicating whether there is the possibility of aliasing.
+ NoAlias = 0,
+ /// The two locations may or may not alias. This is the least precise
+ /// result.
+ MayAlias,
+ /// The two locations alias, but only due to a partial overlap.
+ PartialAlias,
+ /// The two locations precisely alias each other.
+ MustAlias,
+ };
+ static_assert(MustAlias < (1 << AliasBits),
+ "Not enough bit field size for the enum!");
+
+ explicit AliasResult() = delete;
+ constexpr AliasResult(const Result &Alias)
+ : Alias(Alias), HasOffset(false), Offset(0) {}
+
+ operator Result() const { return static_cast<Result>(Alias); }
+
+ constexpr bool hasOffset() const { return HasOffset; }
+ constexpr int32_t getOffset() const {
+ assert(HasOffset && "No offset!");
+ return Offset;
+ }
+ void setOffset(int32_t NewOffset) {
+ if (isInt<OffsetBits>(NewOffset)) {
+ HasOffset = true;
+ Offset = NewOffset;
+ }
+ }
+
+ /// Helper for processing AliasResult for swapped memory location pairs.
+ void swap(bool DoSwap) {
+ if (DoSwap && hasOffset())
+ setOffset(-getOffset());
+ }
};
+static_assert(sizeof(AliasResult) == 4,
+ "AliasResult size is intended to be 4 bytes!");
+
/// << operator for AliasResult.
raw_ostream &operator<<(raw_ostream &OS, AliasResult AR);
@@ -369,16 +412,6 @@ template <> struct DenseMapInfo<AACacheLoc> {
/// The information stored in an `AAQueryInfo` is currently limitted to the
/// caches used by BasicAA, but can further be extended to fit other AA needs.
class AAQueryInfo {
- /// Storage for estimated relative offsets between two partially aliased
- /// values. Used to optimize out redundant parts of loads/stores (in GVN/DSE).
- /// These users cannot process quite complicated addresses (e.g. GEPs with
- /// non-constant offsets). Used by BatchAAResults only.
- bool CacheOffsets = false;
- SmallDenseMap<std::pair<std::pair<const Value *, const Value *>,
- std::pair<uint64_t, uint64_t>>,
- int64_t, 4>
- ClobberOffsets;
-
public:
using LocPair = std::pair<AACacheLoc, AACacheLoc>;
struct CacheEntry {
@@ -406,9 +439,7 @@ class AAQueryInfo {
/// assumption is disproven.
SmallVector<AAQueryInfo::LocPair, 4> AssumptionBasedResults;
- AAQueryInfo(bool CacheOffsets = false)
- : CacheOffsets(CacheOffsets), ClobberOffsets(), AliasCache(),
- IsCapturedCache() {}
+ AAQueryInfo() : AliasCache(), IsCapturedCache() {}
/// Create a new AAQueryInfo based on this one, but with the cache cleared.
/// This is used for recursive queries across phis, where cache results may
@@ -418,33 +449,6 @@ class AAQueryInfo {
NewAAQI.Depth = Depth;
return NewAAQI;
}
-
- Optional<int64_t> getClobberOffset(const Value *Ptr1, const Value *Ptr2,
- uint64_t Size1, uint64_t Size2) const {
- assert(CacheOffsets && "Clobber offset cached in batch mode only!");
- const bool Swapped = Ptr1 > Ptr2;
- if (Swapped) {
- std::swap(Ptr1, Ptr2);
- std::swap(Size1, Size2);
- }
- const auto IOff = ClobberOffsets.find({{Ptr1, Ptr2}, {Size1, Size2}});
- if (IOff != ClobberOffsets.end())
- return Swapped ? -IOff->second : IOff->second;
- return None;
- }
-
- void setClobberOffset(const Value *Ptr1, const Value *Ptr2, uint64_t Size1,
- uint64_t Size2, int64_t Offset) {
- // Cache offset for batch mode only.
- if (!CacheOffsets)
- return;
- if (Ptr1 > Ptr2) {
- std::swap(Ptr1, Ptr2);
- std::swap(Size1, Size2);
- Offset = -Offset;
- }
- ClobberOffsets[{{Ptr1, Ptr2}, {Size1, Size2}}] = Offset;
- }
};
class BatchAAResults;
@@ -887,8 +891,7 @@ class BatchAAResults {
AAQueryInfo AAQI;
public:
- BatchAAResults(AAResults &AAR, bool CacheOffsets = false)
- : AA(AAR), AAQI(CacheOffsets) {}
+ BatchAAResults(AAResults &AAR) : AA(AAR), AAQI() {}
AliasResult alias(const MemoryLocation &LocA, const MemoryLocation &LocB) {
return AA.alias(LocA, LocB, AAQI);
}
@@ -922,8 +925,6 @@ class BatchAAResults {
MemoryLocation(V2, LocationSize::precise(1))) ==
AliasResult::MustAlias;
}
- Optional<int64_t> getClobberOffset(const MemoryLocation &LocA,
- const MemoryLocation &LocB) const;
};
/// Temporary typedef for legacy code that uses a generic \c AliasAnalysis
diff --git a/llvm/include/llvm/Analysis/AliasSetTracker.h b/llvm/include/llvm/Analysis/AliasSetTracker.h
index ee6c371435e7..b9d8593937d4 100644
--- a/llvm/include/llvm/Analysis/AliasSetTracker.h
+++ b/llvm/include/llvm/Analysis/AliasSetTracker.h
@@ -35,18 +35,17 @@
namespace llvm {
class AAResults;
+class AliasResult;
class AliasSetTracker;
-class BasicBlock;
-class LoadInst;
class AnyMemSetInst;
class AnyMemTransferInst;
+class BasicBlock;
+class LoadInst;
class raw_ostream;
class StoreInst;
class VAArgInst;
class Value;
-enum AliasResult : uint8_t;
-
class AliasSet : public ilist_node<AliasSet> {
friend class AliasSetTracker;
diff --git a/llvm/include/llvm/Analysis/MemorySSA.h b/llvm/include/llvm/Analysis/MemorySSA.h
index 22d3eae1edd2..5b32f5cec887 100644
--- a/llvm/include/llvm/Analysis/MemorySSA.h
+++ b/llvm/include/llvm/Analysis/MemorySSA.h
@@ -299,8 +299,9 @@ class MemoryUseOrDef : public MemoryAccess {
OptimizedAccessAlias = AR;
}
- void setDefiningAccess(MemoryAccess *DMA, bool Optimized = false,
- Optional<AliasResult> AR = AliasResult::MayAlias) {
+ void setDefiningAccess(
+ MemoryAccess *DMA, bool Optimized = false,
+ Optional<AliasResult> AR = AliasResult(AliasResult::MayAlias)) {
if (!Optimized) {
setOperand(0, DMA);
return;
diff --git a/llvm/lib/Analysis/AliasAnalysis.cpp b/llvm/lib/Analysis/AliasAnalysis.cpp
index f4e9e143ff8b..c73989731ab1 100644
--- a/llvm/lib/Analysis/AliasAnalysis.cpp
+++ b/llvm/lib/Analysis/AliasAnalysis.cpp
@@ -958,17 +958,6 @@ AAResults llvm::createLegacyPMAAResults(Pass &P, Function &F,
return AAR;
}
-Optional<int64_t>
-BatchAAResults::getClobberOffset(const MemoryLocation &LocA,
- const MemoryLocation &LocB) const {
- if (!LocA.Size.hasValue() || !LocB.Size.hasValue())
- return None;
- const Value *V1 = LocA.Ptr->stripPointerCastsForAliasAnalysis();
- const Value *V2 = LocB.Ptr->stripPointerCastsForAliasAnalysis();
- return AAQI.getClobberOffset(V1, V2, LocA.Size.getValue(),
- LocB.Size.getValue());
-}
-
bool llvm::isNoAliasCall(const Value *V) {
if (const auto *Call = dyn_cast<CallBase>(V))
return Call->hasRetAttr(Attribute::NoAlias);
diff --git a/llvm/lib/Analysis/BasicAliasAnalysis.cpp b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
index 9992725ebe74..4fe7d668b1dc 100644
--- a/llvm/lib/Analysis/BasicAliasAnalysis.cpp
+++ b/llvm/lib/Analysis/BasicAliasAnalysis.cpp
@@ -1015,14 +1015,15 @@ AliasResult BasicAAResult::aliasGEP(
// TODO: This limitation exists for compile-time reasons. Relax it if we
// can avoid exponential pathological cases.
if (!isa<GEPOperator>(V2))
- return MayAlias;
+ return AliasResult::MayAlias;
// If both accesses have unknown size, we can only check whether the base
// objects don't alias.
AliasResult BaseAlias = getBestAAResults().alias(
MemoryLocation::getBeforeOrAfter(UnderlyingV1),
MemoryLocation::getBeforeOrAfter(UnderlyingV2), AAQI);
- return BaseAlias == NoAlias ? NoAlias : MayAlias;
+ return BaseAlias == AliasResult::NoAlias ? AliasResult::NoAlias
+ : AliasResult::MayAlias;
}
DecomposedGEP DecompGEP1 = DecomposeGEPExpression(GEP1, DL, &AC, DT);
@@ -1090,8 +1091,9 @@ AliasResult BasicAAResult::aliasGEP(
const Value *RightPtr = GEP1;
LocationSize VLeftSize = V2Size;
LocationSize VRightSize = V1Size;
+ const bool Swapped = Off.isNegative();
- if (Off.isNegative()) {
+ if (Swapped) {
// Swap if we have the situation where:
// + +
// | BaseOffset |
@@ -1108,16 +1110,16 @@ AliasResult BasicAAResult::aliasGEP(
if (Off.ult(LSize)) {
// Conservatively drop processing if a phi was visited and/or offset is
// too big.
+ AliasResult AR = AliasResult::PartialAlias;
if (VisitedPhiBBs.empty() && VRightSize.hasValue() &&
- Off.ule(INT64_MAX)) {
+ Off.ule(INT32_MAX) && (Off + VRightSize.getValue()).ule(LSize)) {
// Memory referenced by right pointer is nested. Save the offset in
- // cache.
- const uint64_t RSize = VRightSize.getValue();
- if ((Off + RSize).ule(LSize))
- AAQI.setClobberOffset(LeftPtr, RightPtr, LSize, RSize,
- Off.getSExtValue());
+ // cache. Note that originally offset estimated as GEP1-V2, but
+ // AliasResult contains the shift that represents GEP1+Offset=V2.
+ AR.setOffset(-Off.getSExtValue());
+ AR.swap(Swapped);
}
- return AliasResult::PartialAlias;
+ return AR;
}
return AliasResult::NoAlias;
}
@@ -1531,7 +1533,8 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
// Check the cache before climbing up use-def chains. This also terminates
// otherwise infinitely recursive queries.
AAQueryInfo::LocPair Locs({V1, V1Size}, {V2, V2Size});
- if (V1 > V2)
+ const bool Swapped = V1 > V2;
+ if (Swapped)
std::swap(Locs.first, Locs.second);
const auto &Pair = AAQI.AliasCache.try_emplace(
Locs, AAQueryInfo::CacheEntry{AliasResult::NoAlias, 0});
@@ -1542,7 +1545,10 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
++Entry.NumAssumptionUses;
++AAQI.NumAssumptionUses;
}
- return Entry.Result;
+ // Cache contains sorted {V1,V2} pairs but we should return original order.
+ auto Result = Entry.Result;
+ Result.swap(Swapped);
+ return Result;
}
int OrigNumAssumptionUses = AAQI.NumAssumptionUses;
@@ -1563,6 +1569,8 @@ AliasResult BasicAAResult::aliasCheck(const Value *V1, LocationSize V1Size,
// This is a definitive result now, when considered as a root query.
AAQI.NumAssumptionUses -= Entry.NumAssumptionUses;
Entry.Result = Result;
+ // Cache contains sorted {V1,V2} pairs.
+ Entry.Result.swap(Swapped);
Entry.NumAssumptionUses = -1;
// If the assumption has been disproven, remove any results that may have
diff --git a/llvm/lib/Analysis/MemorySSA.cpp b/llvm/lib/Analysis/MemorySSA.cpp
index 3576354984df..f6f7d9cb3ce3 100644
--- a/llvm/lib/Analysis/MemorySSA.cpp
+++ b/llvm/lib/Analysis/MemorySSA.cpp
@@ -286,7 +286,7 @@ instructionClobbersQuery(const MemoryDef *MD, const MemoryLocation &UseLoc,
case Intrinsic::invariant_end:
case Intrinsic::assume:
case Intrinsic::experimental_noalias_scope_decl:
- return {false, AliasResult::NoAlias};
+ return {false, AliasResult(AliasResult::NoAlias)};
case Intrinsic::dbg_addr:
case Intrinsic::dbg_declare:
case Intrinsic::dbg_label:
@@ -305,7 +305,8 @@ instructionClobbersQuery(const MemoryDef *MD, const MemoryLocation &UseLoc,
if (auto *DefLoad = dyn_cast<LoadInst>(DefInst))
if (auto *UseLoad = dyn_cast_or_null<LoadInst>(UseInst))
- return {!areLoadsReorderable(UseLoad, DefLoad), AliasResult::MayAlias};
+ return {!areLoadsReorderable(UseLoad, DefLoad),
+ AliasResult(AliasResult::MayAlias)};
ModRefInfo I = AA.getModRefInfo(DefInst, UseLoc);
AR = isMustSet(I) ? AliasResult::MustAlias : AliasResult::MayAlias;
@@ -344,7 +345,7 @@ struct UpwardsMemoryQuery {
const Instruction *Inst = nullptr;
// The MemoryAccess we actually got called with, used to test local domination
const MemoryAccess *OriginalAccess = nullptr;
- Optional<AliasResult> AR = AliasResult::MayAlias;
+ Optional<AliasResult> AR = AliasResult(AliasResult::MayAlias);
bool SkipSelfAccess = false;
UpwardsMemoryQuery() = default;
@@ -570,14 +571,14 @@ template <class AliasAnalysisType> class ClobberWalker {
for (MemoryAccess *Current : def_chain(Desc.Last)) {
Desc.Last = Current;
if (Current == StopAt || Current == SkipStopAt)
- return {Current, false, AliasResult::MayAlias};
+ return {Current, false, AliasResult(AliasResult::MayAlias)};
if (auto *MD = dyn_cast<MemoryDef>(Current)) {
if (MSSA.isLiveOnEntryDef(MD))
- return {MD, true, AliasResult::MustAlias};
+ return {MD, true, AliasResult(AliasResult::MustAlias)};
if (!--*UpwardWalkLimit)
- return {Current, true, AliasResult::MayAlias};
+ return {Current, true, AliasResult(AliasResult::MayAlias)};
ClobberAlias CA =
instructionClobbersQuery(MD, Desc.Loc, Query->Inst, AA);
@@ -591,7 +592,7 @@ template <class AliasAnalysisType> class ClobberWalker {
assert(isa<MemoryPhi>(Desc.Last) &&
"Ended at a non-clobber that's not a phi?");
- return {Desc.Last, false, AliasResult::MayAlias};
+ return {Desc.Last, false, AliasResult(AliasResult::MayAlias)};
}
void addSearches(MemoryPhi *Phi, SmallVectorImpl<ListIndex> &PausedSearches,
@@ -2490,8 +2491,9 @@ MemorySSA::ClobberWalkerBase<AliasAnalysisType>::getClobberingMemoryAccessBase(
StartingAccess->setOptimized(OptimizedAccess);
if (MSSA->isLiveOnEntryDef(OptimizedAccess))
StartingAccess->setOptimizedAccessType(None);
- else if (Q.AR == AliasResult::MustAlias)
- StartingAccess->setOptimizedAccessType(AliasResult::MustAlias);
+ else if (Q.AR && *Q.AR == AliasResult::MustAlias)
+ StartingAccess->setOptimizedAccessType(
+ AliasResult(AliasResult::MustAlias));
} else
OptimizedAccess = StartingAccess->getOptimized();
diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
index 4b5b705442d1..d3052e0a4cc3 100644
--- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
+++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp
@@ -402,9 +402,9 @@ isOverwrite(const Instruction *LaterI, const Instruction *EarlierI,
}
// If we hit a partial alias we may have a full overwrite
- if (AAR == AliasResult::PartialAlias) {
- int64_t Off = AA.getClobberOffset(Later, Earlier).getValueOr(0);
- if (Off > 0 && (uint64_t)Off + EarlierSize <= LaterSize)
+ if (AAR == AliasResult::PartialAlias && AAR.hasOffset()) {
+ int32_t Off = AAR.getOffset();
+ if (Off >= 0 && (uint64_t)Off + EarlierSize <= LaterSize)
return OW_Complete;
}
@@ -996,8 +996,8 @@ struct DSEState {
DSEState(Function &F, AliasAnalysis &AA, MemorySSA &MSSA, DominatorTree &DT,
PostDominatorTree &PDT, const TargetLibraryInfo &TLI)
- : F(F), AA(AA), BatchAA(AA, /*CacheOffsets =*/true), MSSA(MSSA), DT(DT),
- PDT(PDT), TLI(TLI), DL(F.getParent()->getDataLayout()) {}
+ : F(F), AA(AA), BatchAA(AA), MSSA(MSSA), DT(DT), PDT(PDT), TLI(TLI),
+ DL(F.getParent()->getDataLayout()) {}
static DSEState get(Function &F, AliasAnalysis &AA, MemorySSA &MSSA,
DominatorTree &DT, PostDominatorTree &PDT,
diff --git a/llvm/unittests/Analysis/AliasAnalysisTest.cpp b/llvm/unittests/Analysis/AliasAnalysisTest.cpp
index 66f29a083204..e7a70e736a1e 100644
--- a/llvm/unittests/Analysis/AliasAnalysisTest.cpp
+++ b/llvm/unittests/Analysis/AliasAnalysisTest.cpp
@@ -309,11 +309,11 @@ TEST_F(AliasAnalysisTest, PartialAliasOffset) {
%i2 = zext i32 %i to i64
%i3 = getelementptr inbounds float, float* %arg, i64 %i2
%i4 = bitcast float* %i3 to <2 x float>*
- %L2 = load <2 x float>, <2 x float>* %i4, align 16
+ %L1 = load <2 x float>, <2 x float>* %i4, align 16
%i7 = add nuw nsw i32 %i, 1
%i8 = zext i32 %i7 to i64
%i9 = getelementptr inbounds float, float* %arg, i64 %i8
- %L1 = load float, float* %i9, align 4
+ %L2 = load float, float* %i9, align 4
ret void
}
)",
@@ -324,18 +324,13 @@ TEST_F(AliasAnalysisTest, PartialAliasOffset) {
Function *F = M->getFunction("foo");
const auto Loc1 = MemoryLocation::get(getInstructionByName(*F, "L1"));
- auto Loc2 = MemoryLocation::get(getInstructionByName(*F, "L2"));
+ const auto Loc2 = MemoryLocation::get(getInstructionByName(*F, "L2"));
auto &AA = getAAResults(*F);
- BatchAAResults BatchAA(AA, /*CacheOffsets =*/true);
- EXPECT_EQ(AliasResult::PartialAlias, BatchAA.alias(Loc1, Loc2));
- EXPECT_EQ(-4, BatchAA.getClobberOffset(Loc1, Loc2).getValueOr(0));
- EXPECT_EQ(4, BatchAA.getClobberOffset(Loc2, Loc1).getValueOr(0));
-
- // Check that no offset returned for
diff erent size.
- Loc2.Size = LocationSize::precise(42);
- EXPECT_EQ(0, BatchAA.getClobberOffset(Loc1, Loc2).getValueOr(0));
+ const auto AR = AA.alias(Loc1, Loc2);
+ EXPECT_EQ(AR, AliasResult::PartialAlias);
+ EXPECT_EQ(4, AR.getOffset());
}
class AAPassInfraTest : public testing::Test {
diff --git a/llvm/unittests/Analysis/MemorySSATest.cpp b/llvm/unittests/Analysis/MemorySSATest.cpp
index 6785a649aaec..3c8aa0159e62 100644
--- a/llvm/unittests/Analysis/MemorySSATest.cpp
+++ b/llvm/unittests/Analysis/MemorySSATest.cpp
@@ -1038,7 +1038,8 @@ TEST_F(MemorySSATest, TestLoadMustAlias) {
}
for (LoadInst *V : {LA3, LA4}) {
MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
- EXPECT_EQ(MemUse->getOptimizedAccessType(), AliasResult::MustAlias)
+ EXPECT_EQ(MemUse->getOptimizedAccessType().getValue(),
+ AliasResult::MustAlias)
<< "Load " << I << " doesn't have the correct alias information";
// EXPECT_EQ expands such that if we increment I above, it won't get
// incremented except when we try to print the error message.
@@ -1087,7 +1088,8 @@ TEST_F(MemorySSATest, TestStoreMustAlias) {
EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
<< "Store " << I << " doesn't have the correct alias information";
else
- EXPECT_EQ(MemDef->getOptimizedAccessType(), AliasResult::MustAlias)
+ EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(),
+ AliasResult::MustAlias)
<< "Store " << I << " doesn't have the correct alias information";
// EXPECT_EQ expands such that if we increment I above, it won't get
// incremented except when we try to print the error message.
@@ -1121,7 +1123,8 @@ TEST_F(MemorySSATest, TestLoadMayAlias) {
unsigned I = 0;
for (LoadInst *V : {LA1, LB1}) {
MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
- EXPECT_EQ(MemUse->getOptimizedAccessType(), AliasResult::MayAlias)
+ EXPECT_EQ(MemUse->getOptimizedAccessType().getValue(),
+ AliasResult::MayAlias)
<< "Load " << I << " doesn't have the correct alias information";
// EXPECT_EQ expands such that if we increment I above, it won't get
// incremented except when we try to print the error message.
@@ -1129,7 +1132,8 @@ TEST_F(MemorySSATest, TestLoadMayAlias) {
}
for (LoadInst *V : {LA2, LB2}) {
MemoryUse *MemUse = dyn_cast_or_null<MemoryUse>(MSSA.getMemoryAccess(V));
- EXPECT_EQ(MemUse->getOptimizedAccessType(), AliasResult::MustAlias)
+ EXPECT_EQ(MemUse->getOptimizedAccessType().getValue(),
+ AliasResult::MustAlias)
<< "Load " << I << " doesn't have the correct alias information";
// EXPECT_EQ expands such that if we increment I above, it won't get
// incremented except when we try to print the error message.
@@ -1189,13 +1193,15 @@ TEST_F(MemorySSATest, TestStoreMayAlias) {
EXPECT_EQ(MemDef->isOptimized(), true)
<< "Store " << I << " was not optimized";
if (I == 1 || I == 3 || I == 4)
- EXPECT_EQ(MemDef->getOptimizedAccessType(), AliasResult::MayAlias)
+ EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(),
+ AliasResult::MayAlias)
<< "Store " << I << " doesn't have the correct alias information";
else if (I == 0 || I == 2)
EXPECT_EQ(MemDef->getOptimizedAccessType(), None)
<< "Store " << I << " doesn't have the correct alias information";
else
- EXPECT_EQ(MemDef->getOptimizedAccessType(), AliasResult::MustAlias)
+ EXPECT_EQ(MemDef->getOptimizedAccessType().getValue(),
+ AliasResult::MustAlias)
<< "Store " << I << " doesn't have the correct alias information";
// EXPECT_EQ expands such that if we increment I above, it won't get
// incremented except when we try to print the error message.
More information about the llvm-commits
mailing list