@@ -91,47 +91,8 @@ bool InstCombinerImpl::SimplifyDemandedBits(Instruction *I, unsigned OpNo,
91
91
KnownBits &Known, unsigned Depth,
92
92
const SimplifyQuery &Q) {
93
93
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);
135
96
if (!NewVal) return false ;
136
97
if (Instruction* OpInst = dyn_cast<Instruction>(U))
137
98
salvageDebugInfo (*OpInst);
@@ -163,21 +124,50 @@ bool InstCombinerImpl::SimplifyDemandedBits(Instruction *I, unsigned OpNo,
163
124
// / operands based on the information about what bits are demanded. This returns
164
125
// / some other non-null value if it found out that V is equal to another value
165
126
// / 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,
168
128
KnownBits &Known,
169
129
unsigned Depth,
170
130
const SimplifyQuery &Q) {
171
- assert (I != nullptr && " Null pointer of Value???" );
131
+ assert (V != nullptr && " Null pointer of Value???" );
172
132
assert (Depth <= MaxAnalysisRecursionDepth && " Limit Search Depth" );
173
133
uint32_t BitWidth = DemandedMask.getBitWidth ();
174
- Type *VTy = I ->getType ();
134
+ Type *VTy = V ->getType ();
175
135
assert (
176
136
(!VTy->isIntOrIntVectorTy () || VTy->getScalarSizeInBits () == BitWidth) &&
177
137
Known.getBitWidth () == BitWidth &&
178
138
" Value *V, DemandedMask and Known must have same BitWidth" );
179
139
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
+
180
164
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 ();
181
171
182
172
// Update flags after simplifying an operand based on the fact that some high
183
173
// order bits are not demanded.
@@ -1115,28 +1105,27 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Instruction *I,
1115
1105
}
1116
1106
1117
1107
if (!KnownBitsComputed)
1118
- llvm::computeKnownBits (I , Known, Depth, Q);
1108
+ llvm::computeKnownBits (V , Known, Depth, Q);
1119
1109
break ;
1120
1110
}
1121
1111
}
1122
1112
1123
- if (I ->getType ()->isPointerTy ()) {
1124
- Align Alignment = I ->getPointerAlignment (DL);
1113
+ if (V ->getType ()->isPointerTy ()) {
1114
+ Align Alignment = V ->getPointerAlignment (DL);
1125
1115
Known.Zero .setLowBits (Log2 (Alignment));
1126
1116
}
1127
1117
1128
1118
// If the client is only demanding bits that we know, return the known
1129
1119
// constant. We can't directly simplify pointers as a constant because of
1130
1120
// pointer provenance.
1131
1121
// 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 ))
1134
1123
return Constant::getIntegerValue (VTy, Known.One );
1135
1124
1136
1125
if (VerifyKnownBits) {
1137
- KnownBits ReferenceKnown = llvm::computeKnownBits (I , Depth, Q);
1126
+ KnownBits ReferenceKnown = llvm::computeKnownBits (V , Depth, Q);
1138
1127
if (Known != ReferenceKnown) {
1139
- errs () << " Mismatched known bits for " << *I << " in "
1128
+ errs () << " Mismatched known bits for " << *V << " in "
1140
1129
<< I->getFunction ()->getName () << " \n " ;
1141
1130
errs () << " computeKnownBits(): " << ReferenceKnown << " \n " ;
1142
1131
errs () << " SimplifyDemandedBits(): " << Known << " \n " ;
0 commit comments