Skip to content

Commit 167c860

Browse files
committed
Revert "[InstCombine] Fix context for multi-use demanded bits simplification"
This reverts commit b558ac0. This breaks a clang test, reverting for now.
1 parent 12c1156 commit 167c860

File tree

5 files changed

+50
-59
lines changed

5 files changed

+50
-59
lines changed

llvm/lib/Transforms/InstCombine/InstCombineInternal.h

Lines changed: 3 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -545,11 +545,10 @@ class LLVM_LIBRARY_VISIBILITY InstCombinerImpl final
545545
ConstantInt *&Less, ConstantInt *&Equal,
546546
ConstantInt *&Greater);
547547

548-
/// Attempts to replace I with a simpler value based on the demanded
548+
/// Attempts to replace V with a simpler value based on the demanded
549549
/// bits.
550-
Value *SimplifyDemandedUseBits(Instruction *I, const APInt &DemandedMask,
551-
KnownBits &Known, unsigned Depth,
552-
const SimplifyQuery &Q);
550+
Value *SimplifyDemandedUseBits(Value *V, APInt DemandedMask, KnownBits &Known,
551+
unsigned Depth, const SimplifyQuery &Q);
553552
using InstCombiner::SimplifyDemandedBits;
554553
bool SimplifyDemandedBits(Instruction *I, unsigned Op,
555554
const APInt &DemandedMask, KnownBits &Known,

llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

Lines changed: 41 additions & 52 deletions
Original file line numberDiff line numberDiff line change
@@ -91,47 +91,8 @@ bool InstCombinerImpl::SimplifyDemandedBits(Instruction *I, unsigned OpNo,
9191
KnownBits &Known, unsigned Depth,
9292
const SimplifyQuery &Q) {
9393
Use &U = I->getOperandUse(OpNo);
94-
Value *V = U.get();
95-
if (isa<Constant>(V)) {
96-
llvm::computeKnownBits(V, Known, Depth, Q);
97-
return false;
98-
}
99-
100-
Known.resetAll();
101-
if (DemandedMask.isZero()) {
102-
// Not demanding any bits from V.
103-
replaceUse(U, UndefValue::get(V->getType()));
104-
return true;
105-
}
106-
107-
if (Depth == MaxAnalysisRecursionDepth)
108-
return false;
109-
110-
Instruction *VInst = dyn_cast<Instruction>(V);
111-
if (!VInst) {
112-
llvm::computeKnownBits(V, Known, Depth, Q);
113-
return false;
114-
}
115-
116-
Value *NewVal;
117-
if (VInst->hasOneUse()) {
118-
// If the instruction has one use, we can directly simplify it.
119-
NewVal = SimplifyDemandedUseBits(VInst, DemandedMask, Known, Depth, Q);
120-
} else if (Depth != 0) {
121-
// If there are multiple uses of this instruction and we aren't at the root,
122-
// then we can simplify VInst to some other value, but not modify the
123-
// instruction.
124-
NewVal =
125-
SimplifyMultipleUseDemandedBits(VInst, DemandedMask, Known, Depth, Q);
126-
} else {
127-
// If this is the root being simplified, allow it to have multiple uses,
128-
// just set the DemandedMask to all bits and reset the context instruction.
129-
// This allows visitTruncInst (for example) to simplify the operand of a
130-
// trunc without duplicating all the SimplifyDemandedUseBits() logic.
131-
NewVal =
132-
SimplifyDemandedUseBits(VInst, APInt::getAllOnes(Known.getBitWidth()),
133-
Known, Depth, Q.getWithInstruction(VInst));
134-
}
94+
Value *NewVal = SimplifyDemandedUseBits(U.get(), DemandedMask, Known,
95+
Depth, Q);
13596
if (!NewVal) return false;
13697
if (Instruction* OpInst = dyn_cast<Instruction>(U))
13798
salvageDebugInfo(*OpInst);
@@ -163,21 +124,50 @@ bool InstCombinerImpl::SimplifyDemandedBits(Instruction *I, unsigned OpNo,
163124
/// operands based on the information about what bits are demanded. This returns
164125
/// some other non-null value if it found out that V is equal to another value
165126
/// in the context where the specified bits are demanded, but not for all users.
166-
Value *InstCombinerImpl::SimplifyDemandedUseBits(Instruction *I,
167-
const APInt &DemandedMask,
127+
Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask,
168128
KnownBits &Known,
169129
unsigned Depth,
170130
const SimplifyQuery &Q) {
171-
assert(I != nullptr && "Null pointer of Value???");
131+
assert(V != nullptr && "Null pointer of Value???");
172132
assert(Depth <= MaxAnalysisRecursionDepth && "Limit Search Depth");
173133
uint32_t BitWidth = DemandedMask.getBitWidth();
174-
Type *VTy = I->getType();
134+
Type *VTy = V->getType();
175135
assert(
176136
(!VTy->isIntOrIntVectorTy() || VTy->getScalarSizeInBits() == BitWidth) &&
177137
Known.getBitWidth() == BitWidth &&
178138
"Value *V, DemandedMask and Known must have same BitWidth");
179139

140+
if (isa<Constant>(V)) {
141+
llvm::computeKnownBits(V, Known, Depth, Q);
142+
return nullptr;
143+
}
144+
145+
Known.resetAll();
146+
if (DemandedMask.isZero()) // Not demanding any bits from V.
147+
return UndefValue::get(VTy);
148+
149+
if (Depth == MaxAnalysisRecursionDepth)
150+
return nullptr;
151+
152+
Instruction *I = dyn_cast<Instruction>(V);
153+
if (!I) {
154+
llvm::computeKnownBits(V, Known, Depth, Q);
155+
return nullptr; // Only analyze instructions.
156+
}
157+
158+
// If there are multiple uses of this value and we aren't at the root, then
159+
// we can't do any simplifications of the operands, because DemandedMask
160+
// only reflects the bits demanded by *one* of the users.
161+
if (Depth != 0 && !I->hasOneUse())
162+
return SimplifyMultipleUseDemandedBits(I, DemandedMask, Known, Depth, Q);
163+
180164
KnownBits LHSKnown(BitWidth), RHSKnown(BitWidth);
165+
// If this is the root being simplified, allow it to have multiple uses,
166+
// just set the DemandedMask to all bits so that we can try to simplify the
167+
// operands. This allows visitTruncInst (for example) to simplify the
168+
// operand of a trunc without duplicating all the logic below.
169+
if (Depth == 0 && !V->hasOneUse())
170+
DemandedMask.setAllBits();
181171

182172
// Update flags after simplifying an operand based on the fact that some high
183173
// order bits are not demanded.
@@ -1115,28 +1105,27 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Instruction *I,
11151105
}
11161106

11171107
if (!KnownBitsComputed)
1118-
llvm::computeKnownBits(I, Known, Depth, Q);
1108+
llvm::computeKnownBits(V, Known, Depth, Q);
11191109
break;
11201110
}
11211111
}
11221112

1123-
if (I->getType()->isPointerTy()) {
1124-
Align Alignment = I->getPointerAlignment(DL);
1113+
if (V->getType()->isPointerTy()) {
1114+
Align Alignment = V->getPointerAlignment(DL);
11251115
Known.Zero.setLowBits(Log2(Alignment));
11261116
}
11271117

11281118
// If the client is only demanding bits that we know, return the known
11291119
// constant. We can't directly simplify pointers as a constant because of
11301120
// pointer provenance.
11311121
// TODO: We could return `(inttoptr const)` for pointers.
1132-
if (!I->getType()->isPointerTy() &&
1133-
DemandedMask.isSubsetOf(Known.Zero | Known.One))
1122+
if (!V->getType()->isPointerTy() && DemandedMask.isSubsetOf(Known.Zero | Known.One))
11341123
return Constant::getIntegerValue(VTy, Known.One);
11351124

11361125
if (VerifyKnownBits) {
1137-
KnownBits ReferenceKnown = llvm::computeKnownBits(I, Depth, Q);
1126+
KnownBits ReferenceKnown = llvm::computeKnownBits(V, Depth, Q);
11381127
if (Known != ReferenceKnown) {
1139-
errs() << "Mismatched known bits for " << *I << " in "
1128+
errs() << "Mismatched known bits for " << *V << " in "
11401129
<< I->getFunction()->getName() << "\n";
11411130
errs() << "computeKnownBits(): " << ReferenceKnown << "\n";
11421131
errs() << "SimplifyDemandedBits(): " << Known << "\n";

llvm/test/Transforms/InstCombine/assume-inseltpoison.ll

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -15,6 +15,8 @@ define i32 @PR40940(<4 x i8> %x) {
1515
; CHECK-LABEL: @PR40940(
1616
; CHECK-NEXT: [[SHUF:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <4 x i32> <i32 1, i32 1, i32 2, i32 3>
1717
; CHECK-NEXT: [[T2:%.*]] = bitcast <4 x i8> [[SHUF]] to i32
18+
; CHECK-NEXT: [[T3:%.*]] = icmp ult i32 [[T2]], 65536
19+
; CHECK-NEXT: call void @llvm.assume(i1 [[T3]])
1820
; CHECK-NEXT: ret i32 [[T2]]
1921
;
2022
%shuf = shufflevector <4 x i8> %x, <4 x i8> poison, <4 x i32> <i32 1, i32 1, i32 2, i32 3>

llvm/test/Transforms/InstCombine/assume.ll

Lines changed: 2 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -428,6 +428,8 @@ define i32 @PR40940(<4 x i8> %x) {
428428
; CHECK-LABEL: @PR40940(
429429
; CHECK-NEXT: [[SHUF:%.*]] = shufflevector <4 x i8> [[X:%.*]], <4 x i8> poison, <4 x i32> <i32 1, i32 1, i32 2, i32 3>
430430
; CHECK-NEXT: [[T2:%.*]] = bitcast <4 x i8> [[SHUF]] to i32
431+
; CHECK-NEXT: [[T3:%.*]] = icmp ult i32 [[T2]], 65536
432+
; CHECK-NEXT: call void @llvm.assume(i1 [[T3]])
431433
; CHECK-NEXT: ret i32 [[T2]]
432434
;
433435
%shuf = shufflevector <4 x i8> %x, <4 x i8> undef, <4 x i32> <i32 1, i32 1, i32 2, i32 3>

llvm/test/Transforms/InstCombine/known-bits.ll

Lines changed: 2 additions & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -2025,16 +2025,15 @@ define i8 @simplifydemanded_context(i8 %x, i8 %y) {
20252025
ret i8 %and2
20262026
}
20272027

2028+
; FIXME: This is a miscompile.
20282029
define i16 @pr97330(i1 %c, ptr %p1, ptr %p2) {
20292030
; CHECK-LABEL: @pr97330(
20302031
; CHECK-NEXT: entry:
20312032
; CHECK-NEXT: br i1 [[C:%.*]], label [[EXIT:%.*]], label [[IF:%.*]]
20322033
; CHECK: if:
20332034
; CHECK-NEXT: unreachable
20342035
; CHECK: exit:
2035-
; CHECK-NEXT: [[V:%.*]] = load i64, ptr [[P1:%.*]], align 8
2036-
; CHECK-NEXT: [[CONV:%.*]] = trunc i64 [[V]] to i16
2037-
; CHECK-NEXT: ret i16 [[CONV]]
2036+
; CHECK-NEXT: ret i16 1
20382037
;
20392038
entry:
20402039
%v = load i64, ptr %p1, align 8

0 commit comments

Comments
 (0)