Lines Matching defs:Known
151 KnownBits &Known, unsigned Depth,
154 void llvm::computeKnownBits(const Value *V, KnownBits &Known, unsigned Depth,
162 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
165 void llvm::computeKnownBits(const Value *V, KnownBits &Known,
170 V, Known, Depth,
296 KnownBits Known = computeKnownBits(V, Depth, SQ);
297 return Known.isNonNegative() &&
298 (Known.isNonZero() || isKnownNonZero(V, SQ, Depth));
326 KnownBits Known(Mask.getBitWidth());
327 computeKnownBits(V, Known, Depth, SQ);
328 return Mask.isSubsetOf(Known.Zero);
375 const APInt &DemandedElts, KnownBits &Known,
378 computeKnownBits(Op1, DemandedElts, Known, Depth + 1, Q);
389 bool isKnownNonNegativeOp1 = Known.isNonNegative();
391 bool isKnownNegativeOp1 = Known.isNegative();
402 (isKnownNegativeOp0 && isKnownNonNegativeOp1 && Known.isNonZero());
410 Known = KnownBits::mul(Known, Known2, SelfMultiply);
417 if (isKnownNonNegative && !Known.isNegative())
418 Known.makeNonNegative();
419 else if (isKnownNegative && !Known.isNonNegative())
420 Known.makeNegative();
424 KnownBits &Known) {
425 unsigned BitWidth = Known.getBitWidth();
429 Known.Zero.setAllBits();
430 Known.One.setAllBits();
444 Known.One &= UnsignedMax & Mask;
445 Known.Zero &= ~UnsignedMax & Mask;
626 Value *LHS, Value *RHS, KnownBits &Known,
634 Known.setAllZero();
638 Known.makeNonNegative();
641 Known.makeNegative();
650 unsigned BitWidth = Known.getBitWidth();
661 Known = Known.unionWith(KnownBits::makeConstant(*C));
666 Known.One |= *C;
668 Known.Zero |= ~*C & *Mask;
672 Known.Zero |= ~*C;
674 Known.One |= *C & ~*Mask;
679 Known = Known.unionWith(KnownBits::makeConstant(*C ^ *Mask));
688 Known = Known.unionWith(RHSKnown);
695 Known.Zero |= RHSKnown.Zero << ShAmt;
696 Known.One |= RHSKnown.One << ShAmt;
703 Known.One |= *BPow2;
713 Known = Known.unionWith(LHSRange.toKnownBits());
720 Known.One.setHighBits(
728 Known.Zero.setHighBits(
738 KnownBits &Known,
749 Known = Known.unionWith(DstKnown.anyext(Known.getBitWidth()));
753 computeKnownBitsFromCmp(V, Pred, LHS, RHS, Known, SQ);
757 KnownBits &Known, unsigned Depth,
762 KnownBits Known2(Known.getBitWidth());
763 KnownBits Known3(Known.getBitWidth());
771 Known = Known.unionWith(Known2);
775 computeKnownBitsFromICmpCond(V, Cmp, Known, SQ, Invert);
778 void llvm::computeKnownBitsFromContext(const Value *V, KnownBits &Known,
782 computeKnownBitsFromCond(V, Q.CC->Cond, Known, Depth, Q, Q.CC->Invert);
792 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
797 computeKnownBitsFromCond(V, BI->getCondition(), Known, Depth, Q,
801 if (Known.hasConflict())
802 Known.resetAll();
808 unsigned BitWidth = Known.getBitWidth();
829 Known.Zero.setLowBits(Log2_64(RK.ArgValue));
843 Known.setAllOnes();
850 Known.setAllZero();
865 computeKnownBitsFromICmpCond(V, Cmp, Known, Q, /*Invert=*/false);
870 if (Known.hasConflict())
871 Known.resetAll();
875 /// non-constant shift amount. Known is the output of this function. Known2 is a
876 /// pre-allocated temporary with the same bit width as Known and on return
883 const Operator *I, const APInt &DemandedElts, KnownBits &Known,
887 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
891 Known.isNonZero() ||
892 (Known.getMaxValue().ult(Known.getBitWidth()) &&
894 Known = KF(Known2, Known, ShAmtNonZero);
1027 void llvm::adjustKnownBitsForSelectArm(KnownBits &Known, Value *Cond,
1031 if (Known.isConstant())
1035 KnownBits CondRes(Known.getBitWidth());
1047 CondRes = CondRes.unionWith(Known);
1058 Known = CondRes;
1063 KnownBits &Known, unsigned Depth,
1065 unsigned BitWidth = Known.getBitWidth();
1073 computeKnownBitsFromRangeMetadata(*MD, Known);
1076 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1079 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1082 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1085 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1088 computeKnownBits(I->getOperand(1), DemandedElts, Known, Depth + 1, Q);
1091 Known = getKnownBitsFromAndXorOr(I, DemandedElts, Known2, Known, Depth, Q);
1096 Known, Known2, Depth, Q);
1100 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1102 Known =
1103 KnownBits::udiv(Known, Known2, Q.IIQ.isExact(cast<BinaryOperator>(I)));
1107 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1109 Known =
1110 KnownBits::sdiv(Known, Known2, Q.IIQ.isExact(cast<BinaryOperator>(I)));
1115 KnownBits Res(Known.getBitWidth());
1121 Known =
1150 Known = Known.anyextOrTrunc(SrcBitWidth);
1151 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1153 Inst && Inst->hasNonNeg() && !Known.isNegative())
1154 Known.makeNonNegative();
1155 Known = Known.zextOrTrunc(BitWidth);
1164 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1182 Known.Zero.setAllBits();
1183 Known.One.setAllBits();
1186 Known = Known.intersectWith(KnownBits::makeConstant(
1190 Known = Known.intersectWith(KnownBits::makeConstant(
1193 Known.Zero.clearSignBit();
1194 Known.One.clearSignBit();
1199 Known.makeNegative();
1201 Known.makeNonNegative();
1218 // Known bits are automatically intersected across demanded elements of a
1245 Known.insertBits(KnownSrc, ShiftElt * SubBitWidth);
1254 Known = Known.trunc(SrcBitWidth);
1255 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1258 Known = Known.sext(BitWidth);
1268 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1273 Known.Zero.setLowBits(C->countr_zero());
1282 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1287 Known.Zero.setHighBits(C->countl_zero());
1296 computeKnownBitsFromShiftOperator(I, DemandedElts, Known, Known2, Depth, Q,
1304 DemandedElts, Known, Known2, Depth, Q);
1311 DemandedElts, Known, Known2, Depth, Q);
1315 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1317 Known = KnownBits::srem(Known, Known2);
1321 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1323 Known = KnownBits::urem(Known, Known2);
1326 Known.Zero.setLowBits(Log2(cast<AllocaInst>(I)->getAlign()));
1331 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1339 if (Known.isUnknown())
1368 Known.resetAll();
1403 Known = KnownBits::computeForAddSub(
1404 /*Add=*/true, /*NSW=*/false, /* NUW=*/false, Known, IndexBits);
1406 if (!Known.isUnknown() && !AccConstIndices.isZero()) {
1408 Known = KnownBits::computeForAddSub(
1409 /*Add=*/true, /*NSW=*/false, /* NUW=*/false, Known, Index);
1444 Known.Zero.setLowBits(Known2.countMinTrailingZeros());
1449 Known.Zero.setHighBits(Known2.countMinLeadingZeros());
1453 Known.Zero.setHighBits(Known2.countMinLeadingZeros());
1454 Known.One.setHighBits(Known2.countMinLeadingOnes());
1487 Known.Zero.setLowBits(std::min(Known2.countMinTrailingZeros(),
1503 Known.makeNonNegative();
1505 Known.makeNegative();
1512 Known.makeNonNegative();
1514 Known.makeNegative();
1520 Known.makeNonNegative();
1533 if (Depth < MaxAnalysisRecursionDepth - 1 && Known.isUnknown()) {
1538 Known.Zero.setAllBits();
1539 Known.One.setAllBits();
1585 Known.resetAll();
1593 Known = Known.intersectWith(Known2);
1596 if (Known.isUnknown())
1609 computeKnownBitsFromRangeMetadata(*MD, Known);
1614 Known = Known.unionWith(Range->toKnownBits());
1619 Known = Known.unionWith(Known2);
1624 if (Known.hasConflict())
1625 Known.resetAll();
1635 Known = Known2.abs(IntMinIsPoison);
1640 Known.Zero |= Known2.Zero.reverseBits();
1641 Known.One |= Known2.One.reverseBits();
1645 Known.Zero |= Known2.Zero.byteSwap();
1646 Known.One |= Known2.One.byteSwap();
1656 Known.Zero.setBitsFrom(LowBits);
1667 Known.Zero.setBitsFrom(LowBits);
1676 Known.Zero.setBitsFrom(LowBits);
1696 Known.Zero =
1698 Known.One =
1703 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1705 Known = KnownBits::uadd_sat(Known, Known2);
1708 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1710 Known = KnownBits::usub_sat(Known, Known2);
1713 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1715 Known = KnownBits::sadd_sat(Known, Known2);
1718 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1720 Known = KnownBits::ssub_sat(Known, Known2);
1724 computeKnownBits(I->getOperand(0), DemandedElts.reverseBits(), Known,
1735 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1738 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1746 Known.Zero |= Known.One;
1749 Known.One.clearAllBits();
1753 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1755 Known = KnownBits::umin(Known, Known2);
1758 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1760 Known = KnownBits::umax(Known, Known2);
1763 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1765 Known = KnownBits::smin(Known, Known2);
1768 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1770 Known = KnownBits::smax(Known, Known2);
1773 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1779 Known &= Known2.anyextOrTrunc(BitWidth);
1785 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1787 Known = KnownBits::mulhs(Known, Known2);
1792 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth + 1, Q);
1794 Known = KnownBits::mulhu(Known, Known2);
1797 Known.Zero.setBitsFrom(32);
1803 Known = computeKnownBitsForHorizontalOperation(
1814 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1822 Known = computeKnownBitsForHorizontalOperation(
1833 Known = computeKnownBitsForHorizontalOperation(I, DemandedElts, Depth,
1856 Known.Zero.setBitsFrom(KnownZeroFirstBit);
1863 Known = getVScaleRange(II->getFunction(), BitWidth).toKnownBits();
1874 Known.resetAll();
1881 Known.resetAll();
1884 Known.One.setAllBits();
1885 Known.Zero.setAllBits();
1888 computeKnownBits(LHS, DemandedLHS, Known, Depth + 1, Q);
1890 if (Known.isUnknown())
1896 Known = Known.intersectWith(Known2);
1902 Known.resetAll();
1917 Known.One.setAllBits();
1918 Known.Zero.setAllBits();
1920 computeKnownBits(Elt, Known, Depth + 1, Q);
1922 if (Known.isUnknown())
1928 Known = Known.intersectWith(Known2);
1940 Known.resetAll();
1947 computeKnownBits(Vec, DemandedVecElts, Known, Depth + 1, Q);
1961 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
1967 /* NUW=*/false, DemandedElts, Known, Known2, Depth, Q);
1972 DemandedElts, Known, Known2, Depth, Q);
1981 computeKnownBits(I->getOperand(0), Known, Depth + 1, Q);
1990 KnownBits Known(getBitWidth(V->getType(), Q.DL));
1991 ::computeKnownBits(V, DemandedElts, Known, Depth, Q);
1992 return Known;
1999 KnownBits Known(getBitWidth(V->getType(), Q.DL));
2000 computeKnownBits(V, Known, Depth, Q);
2001 return Known;
2005 /// them in the Known bit set.
2020 KnownBits &Known, unsigned Depth,
2024 Known.resetAll();
2033 unsigned BitWidth = Known.getBitWidth();
2050 "V and Known should have same BitWidth");
2053 "V and Known should have same BitWidth");
2060 Known = KnownBits::makeConstant(*C);
2065 Known.setAllZero();
2074 Known.Zero.setAllBits(); Known.One.setAllBits();
2079 Known.Zero &= ~Elt;
2080 Known.One &= Elt;
2082 if (Known.hasConflict())
2083 Known.resetAll();
2091 Known.Zero.setAllBits(); Known.One.setAllBits();
2100 Known.resetAll();
2104 Known.Zero &= ~Elt;
2105 Known.One &= Elt;
2107 if (Known.hasConflict())
2108 Known.resetAll();
2113 Known.resetAll();
2125 Known = Range->toKnownBits();
2135 computeKnownBits(GA->getAliasee(), Known, Depth + 1, Q);
2140 computeKnownBitsFromOperator(I, DemandedElts, Known, Depth, Q);
2143 Known = CR->toKnownBits();
2146 // Aligned pointers have trailing zeros - refine Known.Zero set
2149 Known.Zero.setLowBits(Log2(Alignment));
2152 // computeKnownBitsFromContext strictly refines Known.
2156 computeKnownBitsFromContext(V, Known, Depth, Q);
2842 KnownBits Known(BitWidth);
2843 computeKnownBits(I->getOperand(0), DemandedElts, Known, Depth, Q);
2844 if (Known.One[0])
2847 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
2858 KnownBits Known =
2860 if (Known.isNegative())
2863 return isNonZeroShift(I, DemandedElts, Depth, Q, Known);
3197 KnownBits Known(BitWidth);
3198 computeKnownBits(I, DemandedElts, Known, Depth, Q);
3199 return Known.One != 0;
3928 KnownBits Known(TyBits);
3929 computeKnownBits(U->getOperand(0), DemandedElts, Known, Depth + 1, Q);
3933 if ((Known.Zero | 1).isAllOnes())
3938 if (Known.isNonNegative())
3955 KnownBits Known(TyBits);
3956 computeKnownBits(U->getOperand(1), DemandedElts, Known, Depth + 1, Q);
3959 if ((Known.Zero | 1).isAllOnes())
3965 if (Known.isNonNegative())
4102 KnownBits Known(TyBits);
4103 computeKnownBits(V, DemandedElts, Known, Depth, Q);
4107 return std::max(FirstAnswer, Known.countMinSignBits());
4845 FPClassTest InterestedClasses, KnownFPClass &Known,
4848 static void computeKnownFPClass(const Value *V, KnownFPClass &Known,
4854 computeKnownFPClass(V, DemandedElts, InterestedClasses, Known, Depth, Q);
4860 KnownFPClass &Known, unsigned Depth,
4873 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
4875 Known.propagateNaN(KnownSrc, true);
4881 FPClassTest InterestedClasses, KnownFPClass &Known,
4883 assert(Known.isUnknown() && "should not be called with known information");
4887 Known.resetAll();
4894 Known.KnownFPClasses = CFP->getValueAPF().classify();
4895 Known.SignBit = CFP->isNegative();
4900 Known.KnownFPClasses = fcPosZero;
4901 Known.SignBit = false;
4906 Known.KnownFPClasses = fcNone;
4907 Known.SignBit = false;
4915 Known.KnownFPClasses = fcNone;
4927 Known = KnownFPClass();
4934 Known = KnownFPClass();
4939 Known.KnownFPClasses |= C.classify();
4946 Known.SignBit = SignBitAllOne;
4971 auto ClearClassesFromFlags = make_scope_exit([=, &Known] {
4972 Known.knownNot(KnownNotFromFlags);
4973 if (!Known.SignBit && AssumedClasses.SignBit) {
4975 Known.signBitMustBeOne();
4977 Known.signBitMustBeZero();
4992 Known, Depth + 1, Q);
4993 Known.fneg();
5037 computeKnownFPClass(LHS, DemandedElts, InterestedClasses & FilterLHS, Known,
5039 Known.KnownFPClasses &= FilterLHS;
5045 Known |= Known2;
5057 InterestedClasses, Known, Depth + 1, Q);
5060 Known.fabs();
5067 Known, Depth + 1, Q);
5070 Known.copysign(KnownSign);
5082 Known.knownNot(fcNegZero);
5090 Known.knownNot(fcNegative);
5104 Known.knownNot(fcPosInf);
5106 Known.knownNot(fcSNan);
5110 Known.knownNot(fcNan);
5113 Known.knownNot(fcNegInf | fcNegSubnormal | fcNegNormal);
5120 Known.knownNot(fcNegZero);
5130 Known.knownNot(fcInf);
5132 Known.knownNot(fcNan);
5146 Known = KnownLHS | KnownRHS;
5150 Known.knownNot(fcNan);
5159 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5165 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5173 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5179 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5189 if ((Known.KnownFPClasses & fcZero) != fcNone &&
5190 !Known.isKnownNeverSubnormal()) {
5198 Known.KnownFPClasses |= fcZero;
5201 if (Known.isKnownNeverNaN()) {
5205 Known.signBitMustBeOne();
5207 Known.signBitMustBeZero();
5215 Known.signBitMustBeZero();
5218 Known.signBitMustBeOne();
5234 Known.KnownFPClasses = KnownSrc.KnownFPClasses | fcZero | fcQNan;
5239 Known.knownNot(fcNan);
5241 Known.knownNot(fcSNan);
5254 Known.knownNot(fcPosZero);
5256 Known.knownNot(fcNegZero);
5261 Known.knownNot(fcSubnormal);
5266 Known.knownNot(fcNegZero);
5276 Known = computeKnownFPClass(II->getArgOperand(0), II->getFastMathFlags(),
5279 if (!Known.isKnownNeverNaN())
5280 Known.SignBit.reset();
5285 Known = computeKnownFPClass(
5306 Known.knownNot(fcSubnormal);
5308 Known.propagateNaN(KnownSrc, true);
5314 Known.knownNot(fcPosInf);
5316 Known.knownNot(fcNegInf);
5321 Known.knownNot(fcPosFinite);
5323 Known.knownNot(fcNegFinite);
5330 Known.knownNot(fcNegative);
5338 Known.knownNot(fcNan);
5339 Known.signBitMustBeZero();
5345 computeKnownFPClassForFPTrunc(Op, DemandedElts, InterestedClasses, Known,
5373 Known.knownNot(fcPosInf);
5376 Known.knownNot(fcNan);
5380 Known.knownNot(fcNegInf);
5396 Known.knownNot(fcNegative);
5412 Known.knownNot(fcNegative);
5419 Known.propagateNaN(KnownSrc, /*PropagateSign=*/true);
5423 Known.knownNot(fcNegative);
5425 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5428 Known.knownNot(fcPositive);
5430 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5448 Known.knownNot(fcSubnormal);
5454 Known.propagateCanonicalizingSrc(KnownSrc, *F, II->getType());
5458 Known.knownNot(fcPosInf);
5460 Known.knownNot(fcNegInf);
5464 Known.knownNot(fcPosSubnormal);
5466 Known.knownNot(fcNegSubnormal);
5468 Known.knownNot(fcPosZero);
5470 Known.knownNot(fcNegZero);
5477 Known, Depth + 1, Q);
5483 Known.knownNot(fcNan);
5486 Known.knownNot(fcNegZero);
5489 Known.knownNot(fcSubnormal);
5492 Known.signBitMustBeZero();
5534 Known.knownNot(fcNan);
5542 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5551 Known.knownNot(fcNegZero);
5561 Known.knownNot(fcNegZero);
5570 Known.knownNot(fcNegative);
5591 Known.signBitMustBeZero();
5593 Known.signBitMustBeOne();
5598 Known.knownNot(fcNan);
5610 Known.knownNot(fcNan);
5620 Known.KnownFPClasses = fcNan | fcPosNormal;
5623 Known.KnownFPClasses = fcNan | fcZero;
5664 Known.knownNot(fcNan);
5670 Known.knownNot(fcNegative);
5676 Known.knownNot(fcNan);
5681 Known.knownNot(KnownFPClass::OrderedLessThanZeroMask);
5683 Known.knownNot(KnownFPClass::OrderedGreaterThanZeroMask);
5687 Known.knownNot(fcNegative);
5689 Known.knownNot(fcPositive);
5697 Known, Depth + 1, Q);
5706 if (Known.KnownFPClasses & fcPosSubnormal)
5707 Known.KnownFPClasses |= fcPosNormal;
5708 if (Known.KnownFPClasses & fcNegSubnormal)
5709 Known.KnownFPClasses |= fcNegNormal;
5710 Known.knownNot(fcSubnormal);
5714 if (!Known.isKnownNeverNaN())
5715 Known.SignBit = std::nullopt;
5719 computeKnownFPClassForFPTrunc(Op, DemandedElts, InterestedClasses, Known,
5726 Known.knownNot(fcNan);
5729 Known.knownNot(fcSubnormal);
5732 Known.knownNot(fcNegZero);
5734 Known.signBitMustBeZero();
5748 Known.knownNot(fcInf);
5765 return computeKnownFPClass(Vec, DemandedVecElts, InterestedClasses, Known,
5789 computeKnownFPClass(Elt, Known, InterestedClasses, Depth + 1, Q);
5791 if (Known.isUnknown())
5794 Known.KnownFPClasses = fcNone;
5802 Known |= Known2;
5817 computeKnownFPClass(LHS, DemandedLHS, InterestedClasses, Known,
5821 if (Known.isUnknown())
5824 Known.KnownFPClasses = fcNone;
5832 Known |= Known2;
5846 Known.knownNot(fcSubnormal);
5855 Known.knownNot(fcNegative);
5858 Known.knownNot(fcNegZero);
5860 Known.knownNot(fcNegInf);
5864 Known.knownNot(fcPositive);
5867 Known.knownNot(fcPosZero);
5869 Known.knownNot(fcPosInf);
5872 Known.propagateNaN(KnownSrc);
5881 computeKnownFPClass(Src, DemandedElts, InterestedClasses, Known, Depth + 1,
5918 Known = KnownSrc;
5921 Known |= KnownSrc;
5924 if (Known.KnownFPClasses == fcAllFlags)
5951 KnownFPClass Known;
5952 ::computeKnownFPClass(V, Known, InterestedClasses, Depth, SQ);
5953 return Known;