Transforms/InstCombine/InstCombineSimplifyDemanded.cpp

55   APInt KnownZero(BitWidth, 0), KnownOne(BitWidth, 0);
59                                      KnownZero, KnownOne, 0);
70                                         APInt &KnownZero, APInt &KnownOne,
73                                           KnownZero, KnownOne, Depth);
86 /// returns false after analyzing the expression and setting KnownOne and known
90 /// the expression. KnownOne and KnownZero always follow the invariant that
91 /// KnownOne & KnownZero == 0. That is, a bit can't be both 1 and 0. Note that
92 /// the bits in KnownOne and KnownZero may only be accurate for those bits set
94 /// and KnownOne must all be the same.
102                                              APInt &KnownZero, APInt &KnownOne,
114          KnownOne.getBitWidth() == BitWidth &&
115          "Value *V, DemandedMask, KnownZero and KnownOne "
119     KnownOne = CI->getValue() & DemandedMask;
120     KnownZero = ~KnownOne & DemandedMask;
125     KnownOne.clearAllBits();
131   KnownOne.clearAllBits();
146     ComputeMaskedBits(V, KnownZero, KnownOne, Depth);
218     // Compute the KnownZero/KnownOne bits to simplify things downstream.
219     ComputeMaskedBits(I, KnownZero, KnownOne, Depth);
232     ComputeMaskedBits(I, KnownZero, KnownOne, Depth);
262     KnownOne = RHSKnownOne & LHSKnownOne;
301     KnownOne = RHSKnownOne | LHSKnownOne;
375     KnownOne = (RHSKnownZero & LHSKnownOne) | (RHSKnownOne & LHSKnownZero);
393     KnownOne = RHSKnownOne & LHSKnownOne;
400     KnownOne = KnownOne.zext(truncBf);
402                              KnownZero, KnownOne, Depth+1))
406     KnownOne = KnownOne.trunc(BitWidth);
407     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
428                              KnownZero, KnownOne, Depth+1))
430     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
438     KnownOne = KnownOne.trunc(SrcBitWidth);
440                              KnownZero, KnownOne, Depth+1))
444     KnownOne = KnownOne.zext(BitWidth);
445     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
465     KnownOne = KnownOne.trunc(SrcBitWidth);
467                              KnownZero, KnownOne, Depth+1))
471     KnownOne = KnownOne.zext(BitWidth);
472     assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
483     } else if (KnownOne[SrcBitWidth-1]) {    // Input sign bit known set
484       KnownOne |= NewBits;
544       KnownOne = ((LHSKnownZero & RHSVal) |
583     ComputeMaskedBits(V, KnownZero, KnownOne, Depth);
602                                                 KnownZero, KnownOne);
619                                KnownZero, KnownOne, Depth+1))
621       assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
623       KnownOne  <<= ShiftAmt;
643                                KnownZero, KnownOne, Depth+1))
645       assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
647       KnownOne  = APIntOps::lshr(KnownOne, ShiftAmt);
688                                KnownZero, KnownOne, Depth+1))
690       assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
694       KnownOne  = APIntOps::lshr(KnownOne, ShiftAmt);
710       } else if ((KnownOne & SignBit) != 0) { // New bits are known one.
711         KnownOne |= HighBits;
734         KnownOne = LHSKnownOne & LowBits;
744           KnownOne |= ~LowBits;
746         assert(!(KnownZero & KnownOne) && "Bits known to be one AND zero?");
816     ComputeMaskedBits(V, KnownZero, KnownOne, Depth);
822   if ((DemandedMask & (KnownZero|KnownOne)) == DemandedMask)
823     return Constant::getIntegerValue(VTy, KnownOne);
845   Instruction *Shl, APInt DemandedMask, APInt &KnownZero, APInt &KnownOne) {
861   KnownOne.clearAllBits();