Lines Matching full:known
28 VerifyKnownBits("instcombine-verify-known-bits",
69 KnownBits &Known) {
70 APInt DemandedMask(APInt::getAllOnes(Known.getBitWidth()));
71 Value *V = SimplifyDemandedUseBits(&Inst, DemandedMask, Known,
82 KnownBits Known(getBitWidth(Inst.getType(), DL));
83 return SimplifyDemandedInstructionBits(Inst, Known);
91 KnownBits &Known, unsigned Depth,
96 llvm::computeKnownBits(V, Known, Depth, Q);
100 Known.resetAll();
112 llvm::computeKnownBits(V, Known, Depth, Q);
119 NewVal = SimplifyDemandedUseBits(VInst, DemandedMask, Known, Depth, Q);
124 SimplifyMultipleUseDemandedBits(VInst, DemandedMask, Known, Depth, Q);
135 /// demanded bits. When this function is called, it is known that only the bits
140 /// analyzing the expression and setting KnownOne and known to be one in the
141 /// expression. Known.Zero contains all the bits that are known to be zero in
145 /// Known.One and Known.Zero always follow the invariant that:
146 /// Known.One & Known.Zero == 0.
147 /// That is, a bit can't be both 1 and 0. The bits in Known.One and Known.Zero
149 /// also that the bitwidth of V, DemandedMask, Known.Zero and Known.One must all
159 KnownBits &Known,
168 Known.getBitWidth() == BitWidth &&
169 "Value *V, DemandedMask and Known must have same BitWidth");
206 llvm::computeKnownBits(I, Known, Depth, Q);
215 Known = analyzeKnownBitsFromAndXorOr(cast<Operator>(I), LHSKnown, RHSKnown,
218 // If the client is only demanding bits that we know, return the known
220 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
221 return Constant::getIntegerValue(VTy, Known.One);
223 // If all of the demanded bits are known 1 on one side, return the other.
246 Known = analyzeKnownBitsFromAndXorOr(cast<Operator>(I), LHSKnown, RHSKnown,
249 // If the client is only demanding bits that we know, return the known
251 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
252 return Constant::getIntegerValue(VTy, Known.One);
254 // If all of the demanded bits are known zero on one side, return the other.
292 Known = analyzeKnownBitsFromAndXorOr(cast<Operator>(I), LHSKnown, RHSKnown,
295 // If the client is only demanding bits that we know, return the known
297 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
298 return Constant::getIntegerValue(VTy, Known.One);
300 // If all of the demanded bits are known zero on one side, return the other.
307 // If all of the demanded bits are known to be zero on one side or the
319 // If all of the demanded bits on one side are known, and all of the set
320 // bits on that side are also known to be set on the other side, turn this
347 // are flipping are known to be set, then the xor is just resetting those
411 // Only known if known in both the LHS and RHS.
416 Known = LHSKnown.intersectWith(RHSKnown);
454 Known = InputKnown.zextOrTrunc(BitWidth);
473 // If the input sign bit is known zero, or if the NewBits are not demanded
483 // If the sign bit of the input is known set or clear, then we know the
485 Known = InputKnown.sext(BitWidth);
534 // If low order bits are not demanded and known to be zero in one operand,
544 // If we are known to be adding zeros to every bit below
562 // Otherwise just compute the known bits of the result.
565 Known = KnownBits::computeForAddSub(true, NSW, NUW, LHSKnown, RHSKnown);
577 // If low order bits are not demanded and are known to be zero in RHS,
587 // If we are known to be subtracting zeros from every bit below
596 // Otherwise just compute the known bits of the result.
599 Known = KnownBits::computeForAddSub(false, NSW, NUW, LHSKnown, RHSKnown);
628 llvm::computeKnownBits(I, Known, Depth, Q);
638 DemandedMask, Known))
649 llvm::computeKnownBits(I, Known, Depth, Q);
695 if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1, Q))
698 Known = KnownBits::shl(Known,
703 // This is a variable shift, so we can't shift the demand mask by a known
708 if (SimplifyDemandedBits(I, 0, DemandedFromOp, Known, Depth + 1, Q)) {
714 llvm::computeKnownBits(I, Known, Depth, Q);
731 llvm::computeKnownBits(I, Known, Depth, Q);
769 if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1, Q)) {
774 Known.Zero.lshrInPlace(ShiftAmt);
775 Known.One.lshrInPlace(ShiftAmt);
777 Known.Zero.setHighBits(ShiftAmt); // high bits known zero.
779 llvm::computeKnownBits(I, Known, Depth, Q);
814 if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1, Q)) {
820 // If the input sign bit is known to be zero, or if none of the shifted in
822 if (Known.Zero[BitWidth - 1] || !ShiftedInBitsDemanded) {
830 Known = KnownBits::ashr(
831 Known, KnownBits::makeConstant(APInt(BitWidth, ShiftAmt)),
834 llvm::computeKnownBits(I, Known, Depth, Q);
853 Known = KnownBits::udiv(LHSKnown, KnownBits::makeConstant(*SA),
856 llvm::computeKnownBits(I, Known, Depth, Q);
878 Known.Zero = LHSKnown.Zero & LowBits;
879 Known.One = LHSKnown.One & LowBits;
884 Known.Zero |= ~LowBits;
889 Known.One |= ~LowBits;
895 llvm::computeKnownBits(I, Known, Depth, Q);
960 Known = LHSKnown & RHSKnown;
967 if (DemandedMask.isSubsetOf(Known.Zero) &&
987 // where only the low bits known to be zero in the pointer are changed
1063 Known.Zero = LHSKnown.Zero.shl(ShiftAmt) |
1065 Known.One = LHSKnown.One.shl(ShiftAmt) |
1096 *II, DemandedMask, Known, KnownBitsComputed);
1105 llvm::computeKnownBits(I, Known, Depth, Q);
1112 Known.Zero.setLowBits(Log2(Alignment));
1115 // If the client is only demanding bits that we know, return the known
1120 DemandedMask.isSubsetOf(Known.Zero | Known.One))
1121 return Constant::getIntegerValue(VTy, Known.One);
1125 if (Known != ReferenceKnown) {
1126 errs() << "Mismatched known bits for " << *I << " in "
1129 errs() << "SimplifyDemandedBits(): " << Known << "\n";
1137 /// Helper routine of SimplifyDemandedUseBits. It computes Known
1141 Instruction *I, const APInt &DemandedMask, KnownBits &Known, unsigned Depth,
1150 // context, we can at least compute the known bits, and we can
1157 Known = analyzeKnownBitsFromAndXorOr(cast<Operator>(I), LHSKnown, RHSKnown,
1159 computeKnownBitsFromContext(I, Known, Depth, Q);
1161 // If the client is only demanding bits that we know, return the known
1163 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
1164 return Constant::getIntegerValue(ITy, Known.One);
1166 // If all of the demanded bits are known 1 on one side, return the other.
1178 Known = analyzeKnownBitsFromAndXorOr(cast<Operator>(I), LHSKnown, RHSKnown,
1180 computeKnownBitsFromContext(I, Known, Depth, Q);
1182 // If the client is only demanding bits that we know, return the known
1184 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
1185 return Constant::getIntegerValue(ITy, Known.One);
1189 // If all of the demanded bits are known zero on one side, return the other.
1201 Known = analyzeKnownBitsFromAndXorOr(cast<Operator>(I), LHSKnown, RHSKnown,
1203 computeKnownBitsFromContext(I, Known, Depth, Q);
1205 // If the client is only demanding bits that we know, return the known
1207 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
1208 return Constant::getIntegerValue(ITy, Known.One);
1212 // If all of the demanded bits are known zero on one side, return the other.
1236 Known =
1238 computeKnownBitsFromContext(I, Known, Depth, Q);
1254 Known = KnownBits::computeForAddSub(/*Add=*/false, NSW, NUW, LHSKnown,
1256 computeKnownBitsFromContext(I, Known, Depth, Q);
1260 // Compute the Known bits to simplify things downstream.
1261 llvm::computeKnownBits(I, Known, Depth, Q);
1263 // If this user is only demanding bits that we know, return the known
1265 if (DemandedMask.isSubsetOf(Known.Zero | Known.One))
1266 return Constant::getIntegerValue(ITy, Known.One);
1287 // Compute the Known bits to simplify things downstream.
1288 llvm::computeKnownBits(I, Known, Depth, Q);
1290 // If this user is only demanding bits that we know, return the known
1292 if (DemandedMask.isSubsetOf(Known.Zero|Known.One))
1293 return Constant::getIntegerValue(ITy, Known.One);
1320 const APInt &ShlOp1, const APInt &DemandedMask, KnownBits &Known) {
1333 Known.One.clearAllBits();
1334 Known.Zero.setLowBits(ShlAmt - 1);
1335 Known.Zero &= DemandedMask;
1729 // element of the select condition is known undef, then we are free to
1745 // either side. If one side is known undef, choosing that side would
1927 // like undef & 0. The result is known zero, not undef.
1959 Value *V, const FPClassTest DemandedMask, KnownFPClass &Known,
1964 assert(Known == KnownFPClass() && "expected uninitialized state");
1975 Known = computeKnownFPClass(V, fcAllFlags, CxtI, Depth + 1);
1977 getFPClassConstant(VTy, DemandedMask & Known.KnownFPClasses);
1987 if (SimplifyDemandedFPClass(I, 0, llvm::fneg(DemandedMask), Known,
1990 Known.fneg();
1997 if (SimplifyDemandedFPClass(I, 0, llvm::inverse_fabs(DemandedMask), Known,
2000 Known.fabs();
2003 if (SimplifyDemandedFPClass(I, 0, DemandedMask, Known, Depth + 1))
2009 if (SimplifyDemandedFPClass(I, 0, DemandedMaskAnySign, Known, Depth + 1))
2026 Known.copysign(KnownSign);
2030 Known = computeKnownFPClass(I, ~DemandedMask, CxtI, Depth + 1);
2048 Known = KnownLHS | KnownRHS;
2052 Known = computeKnownFPClass(I, ~DemandedMask, CxtI, Depth + 1);
2056 return getFPClassConstant(VTy, DemandedMask & Known.KnownFPClasses);
2061 KnownFPClass &Known,
2065 SimplifyDemandedUseFPClass(U.get(), DemandedMask, Known, Depth, I);