reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/CodeGen/SelectionDAG/TargetLowering.cpp
  772   Known = KnownBits(BitWidth);
  780     Known.One = cast<ConstantSDNode>(Op)->getAPIntValue();
  781     Known.Zero = ~Known.One;
  781     Known.Zero = ~Known.One;
  791       Known = TLO.DAG.computeKnownBits(Op, DemandedElts, Depth);
  820     Known = SrcKnown.zextOrTrunc(BitWidth, false);
  826     Known = TLO.DAG.computeKnownBits(Op, DemandedElts, Depth);
  831       Known = TLO.DAG.computeKnownBits(Op, DemandedElts, Depth);
  860     Known = KnownScl.zextOrTrunc(BitWidth, false);
  868       Known.One &= KnownVec.One;
  869       Known.Zero &= KnownVec.Zero;
  901     Known.Zero.setAllBits();
  902     Known.One.setAllBits();
  904         Known.One &= KnownSub.One;
  905         Known.Zero &= KnownSub.Zero;
  908         Known.One &= KnownBase.One;
  909         Known.Zero &= KnownBase.Zero;
  924     if (SimplifyDemandedBits(Src, DemandedBits, SrcElts, Known, TLO, Depth + 1))
  929     Known.Zero.setAllBits();
  930     Known.One.setAllBits();
  942         Known.One &= Known2.One;
  943         Known.Zero &= Known2.Zero;
  976       Known.Zero.setAllBits();
  977       Known.One.setAllBits();
  982         Known.One &= Known2.One;
  983         Known.Zero &= Known2.Zero;
  989         Known.One &= Known2.One;
  990         Known.Zero &= Known2.Zero;
 1040     if (SimplifyDemandedBits(Op1, DemandedBits, DemandedElts, Known, TLO,
 1043     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1044     if (SimplifyDemandedBits(Op0, ~Known.Zero & DemandedBits, DemandedElts,
 1065     if (DemandedBits.isSubsetOf(Known2.Zero | Known.One))
 1067     if (DemandedBits.isSubsetOf(Known.Zero | Known2.One))
 1070     if (DemandedBits.isSubsetOf(Known.Zero | Known2.Zero))
 1080     Known.One &= Known2.One;
 1082     Known.Zero |= Known2.Zero;
 1089     if (SimplifyDemandedBits(Op1, DemandedBits, DemandedElts, Known, TLO,
 1092     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1093     if (SimplifyDemandedBits(Op0, ~Known.One & DemandedBits, DemandedElts,
 1114     if (DemandedBits.isSubsetOf(Known2.One | Known.Zero))
 1116     if (DemandedBits.isSubsetOf(Known.One | Known2.Zero))
 1126     Known.Zero &= Known2.Zero;
 1128     Known.One |= Known2.One;
 1135     if (SimplifyDemandedBits(Op1, DemandedBits, DemandedElts, Known, TLO,
 1138     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1160     if (DemandedBits.isSubsetOf(Known.Zero))
 1171     if (DemandedBits.isSubsetOf(Known.Zero | Known2.Zero))
 1175     KnownOut.Zero = (Known.Zero & Known2.Zero) | (Known.One & Known2.One);
 1175     KnownOut.Zero = (Known.Zero & Known2.Zero) | (Known.One & Known2.One);
 1177     KnownOut.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
 1177     KnownOut.One = (Known.Zero & Known2.One) | (Known.One & Known2.Zero);
 1206     Known = std::move(KnownOut);
 1210     if (SimplifyDemandedBits(Op.getOperand(2), DemandedBits, Known, TLO,
 1216     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1224     Known.One &= Known2.One;
 1225     Known.Zero &= Known2.Zero;
 1228     if (SimplifyDemandedBits(Op.getOperand(3), DemandedBits, Known, TLO,
 1234     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1242     Known.One &= Known2.One;
 1243     Known.Zero &= Known2.Zero;
 1270       Known.Zero.setBitsFrom(1);
 1312                                Known, TLO, Depth + 1))
 1363       Known.Zero <<= ShAmt;
 1364       Known.One <<= ShAmt;
 1366       Known.Zero.setLowBits(ShAmt);
 1418       if (SimplifyDemandedBits(Op0, InDemandedMask, DemandedElts, Known, TLO,
 1421       assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1422       Known.Zero.lshrInPlace(ShAmt);
 1423       Known.One.lshrInPlace(ShAmt);
 1425       Known.Zero.setHighBits(ShAmt); // High bits known zero.
 1461       if (SimplifyDemandedBits(Op0, InDemandedMask, DemandedElts, Known, TLO,
 1464       assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1465       Known.Zero.lshrInPlace(ShAmt);
 1466       Known.One.lshrInPlace(ShAmt);
 1470       if (Known.Zero[BitWidth - ShAmt - 1] ||
 1486       if (Known.One[BitWidth - ShAmt - 1])
 1488         Known.One.setHighBits(ShAmt);
 1506                                  Known, TLO, Depth + 1))
 1518       if (SimplifyDemandedBits(Op1, Demanded1, DemandedElts, Known, TLO,
 1524       Known.One.lshrInPlace(IsFSHL ? (BitWidth - Amt) : Amt);
 1525       Known.Zero.lshrInPlace(IsFSHL ? (BitWidth - Amt) : Amt);
 1526       Known.One |= Known2.One;
 1527       Known.Zero |= Known2.Zero;
 1537     Known.One = Known2.One.reverseBits();
 1538     Known.Zero = Known2.Zero.reverseBits();
 1576     if (SimplifyDemandedBits(Op0, InputDemandedBits, Known, TLO, Depth + 1))
 1578     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1584     if (Known.Zero[ExVTBits - 1])
 1589     if (Known.One[ExVTBits - 1]) { // Input sign bit known set
 1590       Known.One.setBitsFrom(ExVTBits);
 1591       Known.Zero &= Mask;
 1593       Known.Zero &= Mask;
 1594       Known.One &= Mask;
 1613     Known.Zero = KnownLo.Zero.zext(BitWidth) |
 1616     Known.One = KnownLo.One.zext(BitWidth) |
 1645     if (SimplifyDemandedBits(Src, InDemandedBits, InDemandedElts, Known, TLO,
 1648     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1649     assert(Known.getBitWidth() == InBits && "Src width has changed?");
 1650     Known = Known.zext(BitWidth, true /* ExtendedBitsAreKnownZero */);
 1650     Known = Known.zext(BitWidth, true /* ExtendedBitsAreKnownZero */);
 1683     if (SimplifyDemandedBits(Src, InDemandedBits, InDemandedElts, Known, TLO,
 1686     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1687     assert(Known.getBitWidth() == InBits && "Src width has changed?");
 1690     Known = Known.sext(BitWidth);
 1690     Known = Known.sext(BitWidth);
 1693     if (Known.isNonNegative()) {
 1718     if (SimplifyDemandedBits(Src, InDemandedBits, InDemandedElts, Known, TLO,
 1721     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1722     assert(Known.getBitWidth() == InBits && "Src width has changed?");
 1723     Known = Known.zext(BitWidth, false /* => any extend */);
 1723     Known = Known.zext(BitWidth, false /* => any extend */);
 1733     if (SimplifyDemandedBits(Src, TruncMask, Known, TLO, Depth + 1))
 1735     Known = Known.trunc(BitWidth);
 1735     Known = Known.trunc(BitWidth);
 1783     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1791     if (SimplifyDemandedBits(Op.getOperand(0), ~InMask | DemandedBits, Known,
 1794     assert(!Known.hasConflict() && "Bits known to be one AND zero?");
 1796     Known.Zero |= ~InMask;
 1821     Known = Known2;
 1823       Known = Known.zext(BitWidth, false /* => any extend */);
 1823       Known = Known.zext(BitWidth, false /* => any extend */);
 1913       Known = TLO.DAG.computeKnownBits(Op, DemandedElts, Depth);
 1985                                             Known, TLO, Depth))
 1991     Known = TLO.DAG.computeKnownBits(Op, DemandedElts, Depth);
 1997   if (DemandedBits.isSubsetOf(Known.Zero | Known.One)) {
 1997   if (DemandedBits.isSubsetOf(Known.Zero | Known.One)) {
 2010       return TLO.CombineTo(Op, TLO.DAG.getConstant(Known.One, dl, VT));