Lines Matching defs:Known
150 KnownBits &Known, unsigned Depth,
153 void llvm::computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
161 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
164 void llvm::computeKnownBits(const Value *V, KnownBits &Known,
169 V, Known, Depth,
304 KnownBits Known = computeKnownBits(V, Depth, SQ);
305 return Known.isNonNegative() &&
306 (Known.isNonZero() || isKnownNonZero(V, SQ, Depth));
335 KnownBits Known(Mask.getBitWidth());
336 computeKnownBits(V, Known, Depth, SQ);
337 return Mask.isSubsetOf(Known.Zero);
385 KnownBits &Known, KnownBits &Known2,
387 computeKnownBits(Op1, DemandedElts, Known, Depth + 1, Q);
398 bool isKnownNonNegativeOp1 = Known.isNonNegative();
400 bool isKnownNegativeOp1 = Known.isNegative();
407 KnownBits One = KnownBits::makeConstant(APInt(Known.getBitWidth(), 1));
408 isKnownNonNegative = KnownBits::sgt(Known, One).value_or(false) ||
418 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.isNonZero());
426 Known = KnownBits::mul(Known, Known2, SelfMultiply);
433 if (isKnownNonNegative && !Known.isNegative())
434 Known.makeNonNegative();
435 else if (isKnownNegative && !Known.isNonNegative())
436 Known.makeNegative();
440 KnownBits &Known) {
441 unsigned BitWidth = Known.getBitWidth();
445 Known.Zero.setAllBits();
446 Known.One.setAllBits();
460 Known.One &= UnsignedMax & Mask;
461 Known.Zero &= ~UnsignedMax & Mask;
678 Value *LHS, Value *RHS, KnownBits &Known,
686 Known.setAllZero();
690 Known.makeNonNegative();
693 Known.makeNegative();
702 unsigned BitWidth = Known.getBitWidth();
713 Known = Known.unionWith(KnownBits::makeConstant(*C));
718 Known.One |= *C;
720 Known.Zero |= ~*C & *Mask;
724 Known.Zero |= ~*C;
726 Known.One |= *C & ~*Mask;
731 Known = Known.unionWith(KnownBits::makeConstant(*C ^ *Mask));
740 Known = Known.unionWith(RHSKnown);
747 Known.Zero |= RHSKnown.Zero << ShAmt;
748 Known.One |= RHSKnown.One << ShAmt;
755 Known.One |= *BPow2;
765 Known = Known.unionWith(LHSRange.toKnownBits());
772 Known.One.setHighBits(
780 Known.Zero.setHighBits(
790 KnownBits &Known,
801 Known = Known.unionWith(DstKnown.anyext(Known.getBitWidth()));
805 computeKnownBitsFromCmp(V, Pred, LHS, RHS, Known, SQ);
809 KnownBits &Known, unsigned Depth,
814 KnownBits Known2(Known.getBitWidth());
815 KnownBits Known3(Known.getBitWidth());
823 Known = Known.unionWith(Known2);
827 computeKnownBitsFromICmpCond(V, Cmp, Known, SQ, Invert);
830 void llvm::computeKnownBitsFromContext(const Value *V, KnownBits &Known,
834 computeKnownBitsFromCond(V, Q.CC->Cond, Known, Depth, Q, Q.CC->Invert);
844 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
849 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
853 if (Known.hasConflict())
854 Known.resetAll();
860 unsigned BitWidth = Known.getBitWidth();
884 Known.Zero.setLowBits(Log2_64(RK.ArgValue));
898 Known.setAllOnes();
905 Known.setAllZero();
920 computeKnownBitsFromICmpCond(V, Cmp, Known, Q, /*Invert=*/false);
925 if (Known.hasConflict())
926 Known.resetAll();
930 /// non-constant shift amount. Known is the output of this function. Known2 is a
931 /// pre-allocated temporary with the same bit width as Known and on return
938 const Operator *I, const APInt &DemandedElts, KnownBits &Known,
942 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
946 Known.isNonZero() ||
947 (Known.getMaxValue().ult(Known.getBitWidth()) &&
949 Known = KF(Known2, Known, ShAmtNonZero);
1082 void llvm::adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond,
1086 if (Known.isConstant())
1090 KnownBits CondRes(Known.getBitWidth());
1102 CondRes = CondRes.unionWith(Known);
1113 Known = CondRes;
1167 KnownBits &Known) {
1170 Known = Known.unionWith(
1176 KnownBits &Known, unsigned Depth,
1178 unsigned BitWidth = Known.getBitWidth();
1186 computeKnownBitsFromRangeMetadata(*MD, Known);
1189 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1192 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1195 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1198 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1201 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1204 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1210 DemandedElts, Known, Known2, Depth, Q);
1214 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1216 Known =
1217 KnownBits::udiv(Known, Known2, Q.IIQ.isExact(cast<BinaryOperator>(I)));
1221 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1223 Known =
1224 KnownBits::sdiv(Known, Known2, Q.IIQ.isExact(cast<BinaryOperator>(I)));
1229 KnownBits Res(Known.getBitWidth());
1235 Known =
1264 Known = Known.anyextOrTrunc(SrcBitWidth);
1265 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1267 Inst && Inst->hasNonNeg() && !Known.isNegative())
1268 Known.makeNonNegative();
1269 Known = Known.zextOrTrunc(BitWidth);
1278 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1296 Known.Zero.setAllBits();
1297 Known.One.setAllBits();
1300 Known = Known.intersectWith(KnownBits::makeConstant(
1304 Known = Known.intersectWith(KnownBits::makeConstant(
1307 Known.Zero.clearSignBit();
1308 Known.One.clearSignBit();
1313 Known.makeNegative();
1315 Known.makeNonNegative();
1332 // Known bits are automatically intersected across demanded elements of a
1359 Known.insertBits(KnownSrc, ShiftElt * SubBitWidth);
1368 Known = Known.trunc(SrcBitWidth);
1369 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1372 Known = Known.sext(BitWidth);
1382 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1387 Known.Zero.setLowBits(C->countr_zero());
1396 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1401 Known.Zero.setHighBits(C->countl_zero());
1410 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1418 DemandedElts, Known, Known2, Depth, Q);
1425 DemandedElts, Known, Known2, Depth, Q);
1429 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1431 Known = KnownBits::srem(Known, Known2);
1435 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1437 Known = KnownBits::urem(Known, Known2);
1440 Known.Zero.setLowBits(Log2(cast<AllocaInst>(I)->getAlign()));
1445 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1453 if (Known.isUnknown())
1482 Known.resetAll();
1517 Known = KnownBits::add(Known, IndexBits);
1519 if (!Known.isUnknown() && !AccConstIndices.isZero()) {
1521 Known = KnownBits::add(Known, Index);
1566 Known.Zero.setLowBits(Known2.countMinTrailingZeros());
1573 Known.Zero.setHighBits(Known2.countMinLeadingZeros());
1577 Known.Zero.setHighBits(Known2.countMinLeadingZeros());
1578 Known.One.setHighBits(Known2.countMinLeadingOnes());
1612 Known.Zero.setLowBits(std::min(Known2.countMinTrailingZeros(),
1631 Known.makeNonNegative();
1633 Known.makeNegative();
1643 Known.makeNonNegative();
1645 Known.makeNegative();
1652 Known.makeNonNegative();
1672 if (Depth < MaxAnalysisRecursionDepth - 1 && Known.isUnknown()) {
1677 Known.Zero.setAllBits();
1678 Known.One.setAllBits();
1728 Known.resetAll();
1736 Known = Known.intersectWith(Known2);
1739 if (Known.isUnknown())
1752 computeKnownBitsFromRangeMetadata(*MD, Known);
1757 Known = Known.unionWith(Range->toKnownBits());
1762 Known = Known.unionWith(Known2);
1767 if (Known.hasConflict())
1768 Known.resetAll();
1778 Known = Known2.abs(IntMinIsPoison);
1783 Known.Zero |= Known2.Zero.reverseBits();
1784 Known.One |= Known2.One.reverseBits();
1788 Known.Zero |= Known2.Zero.byteSwap();
1789 Known.One |= Known2.One.byteSwap();
1799 Known.Zero.setBitsFrom(LowBits);
1810 Known.Zero.setBitsFrom(LowBits);
1819 Known.Zero.setBitsFrom(LowBits);
1839 Known.Zero =
1841 Known.One =
1846 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1848 Known = KnownBits::uadd_sat(Known, Known2);
1851 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1853 Known = KnownBits::usub_sat(Known, Known2);
1856 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1858 Known = KnownBits::sadd_sat(Known, Known2);
1861 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1863 Known = KnownBits::ssub_sat(Known, Known2);
1867 computeKnownBits(I->getOperand(0), DemandedElts.reverseBits(), Known,
1878 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1881 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1889 Known.Zero |= Known.One;
1892 Known.One.clearAllBits();
1896 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1898 Known = KnownBits::umin(Known, Known2);
1901 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1903 Known = KnownBits::umax(Known, Known2);
1906 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1908 Known = KnownBits::smin(Known, Known2);
1909 unionWithMinMaxIntrinsicClamp(II, Known);
1912 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1914 Known = KnownBits::smax(Known, Known2);
1915 unionWithMinMaxIntrinsicClamp(II, Known);
1918 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1924 Known &= Known2.anyextOrTrunc(BitWidth);
1930 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1932 Known = KnownBits::mulhs(Known, Known2);
1937 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1939 Known = KnownBits::mulhu(Known, Known2);
1942 Known.Zero.setBitsFrom(32);
1948 Known = computeKnownBitsForHorizontalOperation(
1957 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1965 Known = computeKnownBitsForHorizontalOperation(
1974 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1997 Known.Zero.setBitsFrom(KnownZeroFirstBit);
2004 Known = getVScaleRange(II->getFunction(), BitWidth).toKnownBits();
2015 Known.resetAll();
2022 Known.resetAll();
2025 Known.One.setAllBits();
2026 Known.Zero.setAllBits();
2029 computeKnownBits(LHS, DemandedLHS, Known, Depth + 1, Q);
2031 if (Known.isUnknown())
2037 Known = Known.intersectWith(Known2);
2043 Known.resetAll();
2058 Known.One.setAllBits();
2059 Known.Zero.setAllBits();
2061 computeKnownBits(Elt, Known, Depth + 1, Q);
2063 if (Known.isUnknown())
2069 Known = Known.intersectWith(Known2);
2081 Known.resetAll();
2088 computeKnownBits(Vec, DemandedVecElts, Known, Depth + 1, Q);
2102 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
2108 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
2113 false, DemandedElts, Known, Known2, Depth, Q);
2122 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
2131 KnownBits Known(getBitWidth(V->getType(), Q.DL));
2132 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
2133 return Known;
2140 KnownBits Known(getBitWidth(V->getType(), Q.DL));
2141 computeKnownBits(V, Known, Depth, Q);
2142 return Known;
2146 /// them in the Known bit set.
2161 KnownBits &Known, unsigned Depth,
2165 Known.resetAll();
2174 unsigned BitWidth = Known.getBitWidth();
2191 "V and Known should have same BitWidth");
2194 "V and Known should have same BitWidth");
2201 Known = KnownBits::makeConstant(*C);
2206 Known.setAllZero();
2215 Known.Zero.setAllBits(); Known.One.setAllBits();
2220 Known.Zero &= ~Elt;
2221 Known.One &= Elt;
2223 if (Known.hasConflict())
2224 Known.resetAll();
2232 Known.Zero.setAllBits(); Known.One.setAllBits();
2241 Known.resetAll();
2245 Known.Zero &= ~Elt;
2246 Known.One &= Elt;
2248 if (Known.hasConflict())
2249 Known.resetAll();
2254 Known.resetAll();
2266 Known = Range->toKnownBits();
2276 computeKnownBits(GA->getAliasee(), Known, Depth + 1, Q);
2281 computeKnownBitsFromOperator(I, DemandedElts, Known, Depth, Q);
2284 Known = CR->toKnownBits();
2287 // Aligned pointers have trailing zeros - refine Known.Zero set
2290 Known.Zero.setLowBits(Log2(Alignment));
2293 // computeKnownBitsFromContext strictly refines Known.
2297 computeKnownBitsFromContext(V, Known, Depth, Q);
3035 KnownBits Known(BitWidth);
3036 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth, Q);
3037 if (Known.One[0])
3040 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
3051 KnownBits Known =
3053 if (Known.isNegative())
3056 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
3390 KnownBits Known(BitWidth);
3391 computeKnownBits(I, DemandedElts, Known, Depth, Q);
3392 return Known.One != 0;
4072 KnownBits Known(TyBits);
4073 computeKnownBits(U->getOperand(0), DemandedElts, Known, Depth + 1, Q);
4077 if ((Known.Zero | 1).isAllOnes())
4082 if (Known.isNonNegative())
4099 KnownBits Known(TyBits);
4100 computeKnownBits(U->getOperand(1), DemandedElts, Known, Depth + 1, Q);
4103 if ((Known.Zero | 1).isAllOnes())
4109 if (Known.isNonNegative())
4246 KnownBits Known(TyBits);
4247 computeKnownBits(V, DemandedElts, Known, Depth, Q);
4251 return std::max(FirstAnswer, Known.countMinSignBits());
5031 FPClassTest InterestedClasses, KnownFPClass &Known,
5034 static void computeKnownFPClass(const Value *V, KnownFPClass &Known,
5040 computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth, Q);
5046 KnownFPClass &Known, unsigned Depth,
5059 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5061 Known.propagateNaN(KnownSrc, true);
5067 FPClassTest InterestedClasses, KnownFPClass &Known,
5069 assert(Known.isUnknown() && "should not be called with known information");
5073 Known.resetAll();
5080 Known.KnownFPClasses = CFP->getValueAPF().classify();
5081 Known.SignBit = CFP->isNegative();
5086 Known.KnownFPClasses = fcPosZero;
5087 Known.SignBit = false;
5092 Known.KnownFPClasses = fcNone;
5093 Known.SignBit = false;
5101 Known.KnownFPClasses = fcNone;
5113 Known = KnownFPClass();
5120 Known = KnownFPClass();
5125 Known.KnownFPClasses |= C.classify();
5132 Known.SignBit = SignBitAllOne;
5157 auto ClearClassesFromFlags = make_scope_exit([=, &Known] {
5158 Known.knownNot(KnownNotFromFlags);
5159 if (!Known.SignBit && AssumedClasses.SignBit) {
5161 Known.signBitMustBeOne();
5163 Known.signBitMustBeZero();
5178 Known, Depth + 1, Q);
5179 Known.fneg();
5223 computeKnownFPClass(LHS, DemandedElts, InterestedClasses & FilterLHS, Known,
5225 Known.KnownFPClasses &= FilterLHS;
5231 Known |= Known2;
5243 InterestedClasses, Known, Depth + 1, Q);
5246 Known.fabs();
5253 Known, Depth + 1, Q);
5256 Known.copysign(KnownSign);
5268 Known.knownNot(fcNegZero);
5276 Known.knownNot(fcNegative);
5290 Known.knownNot(fcPosInf);
5292 Known.knownNot(fcSNan);
5296 Known.knownNot(fcNan);
5299 Known.knownNot(fcNegInf | fcNegSubnormal | fcNegNormal);
5306 Known.knownNot(fcNegZero);
5316 Known.knownNot(fcInf);
5318 Known.knownNot(fcNan);
5332 Known = KnownLHS | KnownRHS;
5336 Known.knownNot(fcNan);
5345 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5351 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5359 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5365 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5375 if ((Known.KnownFPClasses & fcZero) != fcNone &&
5376 !Known.isKnownNeverSubnormal()) {
5384 Known.KnownFPClasses |= fcZero;
5387 if (Known.isKnownNeverNaN()) {
5391 Known.signBitMustBeOne();
5393 Known.signBitMustBeZero();
5401 Known.signBitMustBeZero();
5404 Known.signBitMustBeOne();
5420 Known.KnownFPClasses = KnownSrc.KnownFPClasses | fcZero | fcQNan;
5425 Known.knownNot(fcNan);
5427 Known.knownNot(fcSNan);
5440 Known.knownNot(fcPosZero);
5442 Known.knownNot(fcNegZero);
5447 Known.knownNot(fcSubnormal);
5452 Known.knownNot(fcNegZero);
5462 Known = computeKnownFPClass(II->getArgOperand(0), II->getFastMathFlags(),
5465 if (!Known.isKnownNeverNaN())
5466 Known.SignBit.reset();
5471 Known = computeKnownFPClass(
5492 Known.knownNot(fcSubnormal);
5494 Known.propagateNaN(KnownSrc, true);
5500 Known.knownNot(fcPosInf);
5502 Known.knownNot(fcNegInf);
5507 Known.knownNot(fcPosFinite);
5509 Known.knownNot(fcNegFinite);
5516 Known.knownNot(fcNegative);
5524 Known.knownNot(fcNan);
5525 Known.signBitMustBeZero();
5531 computeKnownFPClassForFPTrunc(Op, DemandedElts, InterestedClasses, Known,
5559 Known.knownNot(fcPosInf);
5562 Known.knownNot(fcNan);
5566 Known.knownNot(fcNegInf);
5582 Known.knownNot(fcNegative);
5598 Known.knownNot(fcNegative);
5605 Known.propagateNaN(KnownSrc, /*PropagateSign=*/true);
5609 Known.knownNot(fcNegative);
5611 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5614 Known.knownNot(fcPositive);
5616 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5634 Known.knownNot(fcSubnormal);
5640 Known.propagateCanonicalizingSrc(KnownSrc, *F, II->getType());
5644 Known.knownNot(fcPosInf);
5646 Known.knownNot(fcNegInf);
5650 Known.knownNot(fcPosSubnormal);
5652 Known.knownNot(fcNegSubnormal);
5654 Known.knownNot(fcPosZero);
5656 Known.knownNot(fcNegZero);
5663 Known, Depth + 1, Q);
5669 Known.knownNot(fcNan);
5672 Known.knownNot(fcNegZero);
5675 Known.knownNot(fcSubnormal);
5678 Known.signBitMustBeZero();
5720 Known.knownNot(fcNan);
5728 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5737 Known.knownNot(fcNegZero);
5747 Known.knownNot(fcNegZero);
5756 Known.knownNot(fcNegative);
5777 Known.signBitMustBeZero();
5779 Known.signBitMustBeOne();
5784 Known.knownNot(fcNan);
5796 Known.knownNot(fcNan);
5806 Known.KnownFPClasses = fcNan | fcPosNormal;
5809 Known.KnownFPClasses = fcNan | fcZero;
5850 Known.knownNot(fcNan);
5856 Known.knownNot(fcNegative);
5862 Known.knownNot(fcNan);
5867 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5869 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5873 Known.knownNot(fcNegative);
5875 Known.knownNot(fcPositive);
5883 Known, Depth + 1, Q);
5892 if (Known.KnownFPClasses & fcPosSubnormal)
5893 Known.KnownFPClasses |= fcPosNormal;
5894 if (Known.KnownFPClasses & fcNegSubnormal)
5895 Known.KnownFPClasses |= fcNegNormal;
5896 Known.knownNot(fcSubnormal);
5900 if (!Known.isKnownNeverNaN())
5901 Known.SignBit = std::nullopt;
5905 computeKnownFPClassForFPTrunc(Op, DemandedElts, InterestedClasses, Known,
5912 Known.knownNot(fcNan);
5915 Known.knownNot(fcSubnormal);
5918 Known.knownNot(fcNegZero);
5920 Known.signBitMustBeZero();
5934 Known.knownNot(fcInf);
5951 return computeKnownFPClass(Vec, DemandedVecElts, InterestedClasses, Known,
5975 computeKnownFPClass(Elt, Known, InterestedClasses, Depth + 1, Q);
5977 if (Known.isUnknown())
5980 Known.KnownFPClasses = fcNone;
5988 Known |= Known2;
6003 computeKnownFPClass(LHS, DemandedLHS, InterestedClasses, Known,
6007 if (Known.isUnknown())
6010 Known.KnownFPClasses = fcNone;
6018 Known |= Known2;
6032 Known.knownNot(fcSubnormal);
6041 Known.knownNot(fcNegative);
6044 Known.knownNot(fcNegZero);
6046 Known.knownNot(fcNegInf);
6050 Known.knownNot(fcPositive);
6053 Known.knownNot(fcPosZero);
6055 Known.knownNot(fcPosInf);
6058 Known.propagateNaN(KnownSrc);
6067 computeKnownFPClass(Src, DemandedElts, InterestedClasses, Known, Depth + 1,
6105 Known = KnownSrc;
6108 Known |= KnownSrc;
6111 if (Known.KnownFPClasses == fcAllFlags)
6130 Known.signBitMustBeZero();
6132 Known.signBitMustBeOne();
6142 Known.KnownFPClasses = fcNan;
6144 Known.knownNot(fcNan);
6153 Known.knownNot(fcInf);
6155 Known.KnownFPClasses = fcInf;
6165 Known.knownNot(fcZero);
6167 Known.KnownFPClasses = fcZero;
6193 KnownFPClass Known;
6194 ::computeKnownFPClass(V, Known, InterestedClasses, Depth, SQ);
6195 return Known;