Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

57   APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
60   Value *V = SimplifyDemandedUseBits(&Inst, DemandedMask, KnownZero, KnownOne,
72                                         APInt &KnownZero, APInt &KnownOne,
76                                           KnownOne, Depth, UserI);
89 /// returns false after analyzing the expression and setting KnownOne and known
93 /// the expression. KnownOne and KnownZero always follow the invariant that
94 /// KnownOne & KnownZero == 0. That is, a bit can't be both 1 and 0. Note that
95 /// the bits in KnownOne and KnownZero may only be accurate for those bits set
97 /// and KnownOne must all be the same.
105                                              APInt &KnownZero, APInt &KnownOne,
115       KnownOne.getBitWidth() == BitWidth &&
116       "Value *V, DemandedMask, KnownZero and KnownOne "
120     KnownOne = CI->getValue() & DemandedMask;
121     KnownZero = ~KnownOne & DemandedMask;
126     KnownOne.clearAllBits();
132   KnownOne.clearAllBits();
147     computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
225     // Compute the KnownZero/KnownOne bits to simplify things downstream.
226     computeKnownBits(I, KnownZero, KnownOne, Depth, CxtI);
239     computeKnownBits(I, KnownZero, KnownOne, Depth, CxtI);
275     KnownOne = RHSKnownOne & LHSKnownOne;
320     KnownOne = RHSKnownOne | LHSKnownOne;
406     KnownOne = (RHSKnownZero & LHSKnownOne) | (RHSKnownOne & LHSKnownZero);
430     KnownOne = RHSKnownOne & LHSKnownOne;
437     KnownOne = KnownOne.zext(truncBf);
439                              KnownOne, Depth + 1))
443     KnownOne = KnownOne.trunc(BitWidth);
444     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
465                              KnownOne, Depth + 1))
467     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
475     KnownOne = KnownOne.trunc(SrcBitWidth);
477                              KnownOne, Depth + 1))
481     KnownOne = KnownOne.zext(BitWidth);
482     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
502     KnownOne = KnownOne.trunc(SrcBitWidth);
504                              KnownOne, Depth + 1))
508     KnownOne = KnownOne.zext(BitWidth);
509     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
520     } else if (KnownOne[SrcBitWidth-1]) {    // Input sign bit known set
521       KnownOne |= NewBits;
551     computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
561                                                 KnownZero, KnownOne);
578                                KnownOne, Depth + 1))
580       assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
582       KnownOne  <<= ShiftAmt;
602                                KnownOne, Depth + 1))
604       assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
606       KnownOne  = APIntOps::lshr(KnownOne, ShiftAmt);
647                                KnownOne, Depth + 1))
649       assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
653       KnownOne  = APIntOps::lshr(KnownOne, ShiftAmt);
669       } else if ((KnownOne & SignBit) != 0) { // New bits are known one.
670         KnownOne |= HighBits;
693         KnownOne = LHSKnownOne & LowBits;
703           KnownOne |= ~LowBits;
705         assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
776     computeKnownBits(V, KnownZero, KnownOne, Depth, CxtI);
782   if ((DemandedMask & (KnownZero|KnownOne)) == DemandedMask)
783     return Constant::getIntegerValue(VTy, KnownOne);
805   Instruction *Shl, APInt DemandedMask, APInt &KnownZero, APInt &KnownOne) {
821   KnownOne.clearAllBits();