Skip to content

Commit 9cb04dc

Browse files
goldsteinngoldsteinn
committed
[Analysis] Share findAffectedValues between DomConditionCache and AssumptionCache; NFC
1 parent 64f0bab commit 9cb04dc

File tree

2 files changed

+78
-89
lines changed

2 files changed

+78
-89
lines changed

‎llvm/lib/Analysis/AssumptionCache.cpp

Lines changed: 20 additions & 62 deletions
Original file line numberDiff line numberDiff line change
@@ -42,6 +42,12 @@ static cl::opt<bool>
4242
cl::desc("Enable verification of assumption cache"),
4343
cl::init(false));
4444

45+
// Implemented in ValueTracking.cpp
46+
void addValueAffectedByCondition(Value *V,
47+
function_ref<void(Value *)> InsertAffected);
48+
void findValuesAffectedByCondition(Value *Cond, bool IsAssume,
49+
function_ref<void(Value *)> InsertAffected);
50+
4551
SmallVector<AssumptionCache::ResultElem, 1> &
4652
AssumptionCache::getOrInsertAffectedValues(Value *V) {
4753
// Try using find_as first to avoid creating extra value handles just for the
@@ -61,85 +67,37 @@ findAffectedValues(CallBase *CI, TargetTransformInfo *TTI,
6167
// Note: This code must be kept in-sync with the code in
6268
// computeKnownBitsFromAssume in ValueTracking.
6369

64-
auto AddAffected = [&Affected](Value *V, unsigned Idx =
65-
AssumptionCache::ExprResultIdx) {
66-
if (isa<Argument>(V) || isa<GlobalValue>(V)) {
67-
Affected.push_back({V, Idx});
68-
} else if (auto *I = dyn_cast<Instruction>(V)) {
69-
Affected.push_back({I, Idx});
70-
71-
// Peek through unary operators to find the source of the condition.
72-
Value *Op;
73-
if (match(I, m_PtrToInt(m_Value(Op)))) {
74-
if (isa<Instruction>(Op) || isa<Argument>(Op))
75-
Affected.push_back({Op, Idx});
76-
}
77-
}
70+
auto InsertAffected = [&Affected](Value *V) {
71+
Affected.push_back({V, AssumptionCache::ExprResultIdx});
7872
};
7973

8074
for (unsigned Idx = 0; Idx != CI->getNumOperandBundles(); Idx++) {
75+
auto AddAffectedBundleVal = [&Affected](Value *V, unsigned Idx) {
76+
if (isa<Argument>(V) || isa<GlobalValue>(V) || isa<Instruction>(V)) {
77+
Affected.push_back({V, Idx});
78+
}
79+
};
8180
OperandBundleUse Bundle = CI->getOperandBundleAt(Idx);
8281
if (Bundle.getTagName() == "separate_storage") {
8382
assert(Bundle.Inputs.size() == 2 &&
8483
"separate_storage must have two args");
85-
AddAffected(getUnderlyingObject(Bundle.Inputs[0]), Idx);
86-
AddAffected(getUnderlyingObject(Bundle.Inputs[1]), Idx);
84+
AddAffectedBundleVal(getUnderlyingObject(Bundle.Inputs[0]), Idx);
85+
AddAffectedBundleVal(getUnderlyingObject(Bundle.Inputs[1]), Idx);
8786
} else if (Bundle.Inputs.size() > ABA_WasOn &&
8887
Bundle.getTagName() != IgnoreBundleTag)
89-
AddAffected(Bundle.Inputs[ABA_WasOn], Idx);
88+
AddAffectedBundleVal(Bundle.Inputs[ABA_WasOn], Idx);
9089
}
9190

92-
Value *Cond = CI->getArgOperand(0), *A, *B;
93-
AddAffected(Cond);
94-
if (match(Cond, m_Not(m_Value(A))))
95-
AddAffected(A);
96-
97-
CmpInst::Predicate Pred;
98-
if (match(Cond, m_Cmp(Pred, m_Value(A), m_Value(B)))) {
99-
AddAffected(A);
100-
AddAffected(B);
101-
102-
if (Pred == ICmpInst::ICMP_EQ) {
103-
if (match(B, m_ConstantInt())) {
104-
Value *X;
105-
// (X & C) or (X | C) or (X ^ C).
106-
// (X << C) or (X >>_s C) or (X >>_u C).
107-
if (match(A, m_BitwiseLogic(m_Value(X), m_ConstantInt())) ||
108-
match(A, m_Shift(m_Value(X), m_ConstantInt())))
109-
AddAffected(X);
110-
}
111-
} else if (Pred == ICmpInst::ICMP_NE) {
112-
Value *X;
113-
// Handle (X & pow2 != 0).
114-
if (match(A, m_And(m_Value(X), m_Power2())) && match(B, m_Zero()))
115-
AddAffected(X);
116-
} else if (Pred == ICmpInst::ICMP_ULT) {
117-
Value *X;
118-
// Handle (A + C1) u< C2, which is the canonical form of A > C3 && A < C4,
119-
// and recognized by LVI at least.
120-
if (match(A, m_Add(m_Value(X), m_ConstantInt())) &&
121-
match(B, m_ConstantInt()))
122-
AddAffected(X);
123-
} else if (CmpInst::isFPPredicate(Pred)) {
124-
// fcmp fneg(x), y
125-
// fcmp fabs(x), y
126-
// fcmp fneg(fabs(x)), y
127-
if (match(A, m_FNeg(m_Value(A))))
128-
AddAffected(A);
129-
if (match(A, m_FAbs(m_Value(A))))
130-
AddAffected(A);
131-
}
132-
} else if (match(Cond, m_Intrinsic<Intrinsic::is_fpclass>(m_Value(A),
133-
m_Value(B)))) {
134-
AddAffected(A);
135-
}
91+
Value *Cond = CI->getArgOperand(0);
92+
findValuesAffectedByCondition(Cond, /*IsAssume*/ true, InsertAffected);
13693

13794
if (TTI) {
13895
const Value *Ptr;
13996
unsigned AS;
14097
std::tie(Ptr, AS) = TTI->getPredicatedAddrSpace(Cond);
14198
if (Ptr)
142-
AddAffected(const_cast<Value *>(Ptr->stripInBoundsOffsets()));
99+
addValueAffectedByCondition(
100+
const_cast<Value *>(Ptr->stripInBoundsOffsets()), InsertAffected);
143101
}
144102
}
145103

‎llvm/lib/Analysis/ValueTracking.cpp

Lines changed: 58 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -9100,7 +9100,7 @@ ConstantRange llvm::computeConstantRange(const Value *V, bool ForSigned,
91009100
return CR;
91019101
}
91029102

9103-
// Used by DomConditionCache
9103+
// Used by DomConditionCache and AssumptionCache.
91049104
void addValueAffectedByCondition(Value *V,
91059105
function_ref<void(Value *)> InsertAffected) {
91069106
using namespace llvm::PatternMatch;
@@ -9126,7 +9126,6 @@ void findValuesAffectedByCondition(Value *Cond, bool IsAssume,
91269126
addValueAffectedByCondition(V, InsertAffected);
91279127
};
91289128

9129-
assert(!IsAssume);
91309129
SmallVector<Value *, 8> Worklist;
91319130
SmallPtrSet<Value *, 8> Visited;
91329131
Worklist.push_back(Cond);
@@ -9136,35 +9135,67 @@ void findValuesAffectedByCondition(Value *Cond, bool IsAssume,
91369135
continue;
91379136

91389137
CmpInst::Predicate Pred;
9139-
Value *A, *B;
9140-
if (match(V, m_LogicalOp(m_Value(A), m_Value(B)))) {
9138+
Value *A, *B, *X;
9139+
9140+
if (IsAssume)
9141+
AddAffected(V);
9142+
9143+
if (IsAssume && match(V, m_Not(m_Value(X))))
9144+
AddAffected(X);
9145+
if (!IsAssume && match(V, m_LogicalOp(m_Value(A), m_Value(B)))) {
91419146
Worklist.push_back(A);
91429147
Worklist.push_back(B);
9143-
} else if (match(V, m_ICmp(Pred, m_Value(A), m_Constant()))) {
9144-
AddAffected(A);
9148+
} else if (match(V, m_Cmp(Pred, m_Value(A), m_Value(B))) &&
9149+
(IsAssume || isa<ICmpInst>(V))) {
9150+
if (IsAssume || match(B, m_Constant())) {
9151+
AddAffected(A);
9152+
if (IsAssume)
9153+
AddAffected(B);
9154+
9155+
if (IsAssume ? (Pred == ICmpInst::ICMP_EQ)
9156+
: ICmpInst::isEquality(Pred)) {
9157+
if (match(B, m_ConstantInt())) {
9158+
// (X & C) or (X | C) or (X ^ C).
9159+
// (X << C) or (X >>_s C) or (X >>_u C).
9160+
if (match(A, m_BitwiseLogic(m_Value(X), m_ConstantInt())) ||
9161+
match(A, m_Shift(m_Value(X), m_ConstantInt())))
9162+
AddAffected(X);
9163+
}
9164+
} else {
9165+
if (Pred == ICmpInst::ICMP_NE)
9166+
if (match(A, m_And(m_Value(X), m_Power2())) && match(B, m_Zero()))
9167+
AddAffected(X);
9168+
9169+
if (!IsAssume || Pred == ICmpInst::ICMP_ULT) {
9170+
// Handle (A + C1) u< C2, which is the canonical form of
9171+
// A > C3 && A < C4.
9172+
if (match(A, m_Add(m_Value(X), m_ConstantInt())) &&
9173+
match(B, m_ConstantInt()))
9174+
AddAffected(X);
9175+
}
9176+
if (!IsAssume) {
9177+
// Handle icmp slt/sgt (bitcast X to int), 0/-1, which is supported
9178+
// by computeKnownFPClass().
9179+
if ((Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGT) &&
9180+
match(A, m_ElementWiseBitCast(m_Value(X))))
9181+
InsertAffected(X);
9182+
}
91459183

9146-
if (ICmpInst::isEquality(Pred)) {
9147-
Value *X;
9148-
// (X & C) or (X | C) or (X ^ C).
9149-
// (X << C) or (X >>_s C) or (X >>_u C).
9150-
if (match(A, m_BitwiseLogic(m_Value(X), m_ConstantInt())) ||
9151-
match(A, m_Shift(m_Value(X), m_ConstantInt())))
9152-
AddAffected(X);
9153-
} else {
9154-
Value *X;
9155-
// Handle (A + C1) u< C2, which is the canonical form of
9156-
// A > C3 && A < C4.
9157-
if (match(A, m_Add(m_Value(X), m_ConstantInt())))
9158-
AddAffected(X);
9159-
// Handle icmp slt/sgt (bitcast X to int), 0/-1, which is supported by
9160-
// computeKnownFPClass().
9161-
if ((Pred == ICmpInst::ICMP_SLT || Pred == ICmpInst::ICMP_SGT) &&
9162-
match(A, m_ElementWiseBitCast(m_Value(X))))
9163-
InsertAffected(X);
9184+
if (IsAssume && CmpInst::isFPPredicate(Pred)) {
9185+
// fcmp fneg(x), y
9186+
// fcmp fabs(x), y
9187+
// fcmp fneg(fabs(x)), y
9188+
if (match(A, m_FNeg(m_Value(A))))
9189+
AddAffected(A);
9190+
if (match(A, m_FAbs(m_Value(A))))
9191+
AddAffected(A);
9192+
}
9193+
}
91649194
}
9165-
} else if (match(Cond, m_CombineOr(m_FCmp(Pred, m_Value(A), m_Constant()),
9166-
m_Intrinsic<Intrinsic::is_fpclass>(
9167-
m_Value(A), m_Constant())))) {
9195+
} else if ((!IsAssume &&
9196+
match(Cond, m_FCmp(Pred, m_Value(A), m_Constant()))) ||
9197+
match(Cond, m_Intrinsic<Intrinsic::is_fpclass>(m_Value(A),
9198+
m_Value(B)))) {
91689199
// Handle patterns that computeKnownFPClass() support.
91699200
AddAffected(A);
91709201
}

0 commit comments

Comments
 (0)