diff --git a/llvm/include/llvm/Support/KnownBits.h b/llvm/include/llvm/Support/KnownBits.h index ba4a5f01036ca..c206bd77d5880 100644 --- a/llvm/include/llvm/Support/KnownBits.h +++ b/llvm/include/llvm/Support/KnownBits.h @@ -48,7 +48,6 @@ struct KnownBits { /// Returns true if we know the value of all bits. bool isConstant() const { - assert(!hasConflict() && "KnownBits conflict!"); return Zero.popcount() + One.popcount() == getBitWidth(); } @@ -74,16 +73,10 @@ struct KnownBits { } /// Returns true if value is all zero. - bool isZero() const { - assert(!hasConflict() && "KnownBits conflict!"); - return Zero.isAllOnes(); - } + bool isZero() const { return Zero.isAllOnes(); } /// Returns true if value is all one bits. - bool isAllOnes() const { - assert(!hasConflict() && "KnownBits conflict!"); - return One.isAllOnes(); - } + bool isAllOnes() const { return One.isAllOnes(); } /// Make all bits known to be zero and discard any previous information. void setAllZero() { diff --git a/llvm/lib/Analysis/ValueTracking.cpp b/llvm/lib/Analysis/ValueTracking.cpp index 08138a5e2f2d9..c7e0c49fd5ccb 100644 --- a/llvm/lib/Analysis/ValueTracking.cpp +++ b/llvm/lib/Analysis/ValueTracking.cpp @@ -1158,7 +1158,6 @@ static void computeKnownBitsFromOperator(const Operator *I, Known.makeNonNegative(); } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); break; } @@ -2055,8 +2054,6 @@ void computeKnownBits(const Value *V, const APInt &DemandedElts, // Check whether we can determine known bits from context such as assumes. computeKnownBitsFromContext(V, Known, Depth, Q); - - assert((Known.Zero & Known.One) == 0 && "Bits known to be one AND zero?"); } /// Try to detect a recurrence that the value of the induction variable is diff --git a/llvm/lib/CodeGen/GlobalISel/GISelKnownBits.cpp b/llvm/lib/CodeGen/GlobalISel/GISelKnownBits.cpp index 32d607cfd71a7..2988fa45b2e33 100644 --- a/llvm/lib/CodeGen/GlobalISel/GISelKnownBits.cpp +++ b/llvm/lib/CodeGen/GlobalISel/GISelKnownBits.cpp @@ -607,7 +607,6 @@ void GISelKnownBits::computeKnownBitsImpl(Register R, KnownBits &Known, } } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); LLVM_DEBUG(dumpResult(MI, Known, Depth)); // Update the cache. diff --git a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp index 09cdec8adb275..ef87882591f19 100644 --- a/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/SelectionDAG.cpp @@ -4212,7 +4212,6 @@ KnownBits SelectionDAG::computeKnownBits(SDValue Op, const APInt &DemandedElts, break; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); return Known; } diff --git a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp index f856c8a51984e..1867b22f60f05 100644 --- a/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp +++ b/llvm/lib/CodeGen/SelectionDAG/TargetLowering.cpp @@ -1436,11 +1436,9 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op1, DemandedBits, DemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); if (SimplifyDemandedBits(Op0, ~Known.Zero & DemandedBits, DemandedElts, Known2, TLO, Depth + 1)) return true; - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // If all of the demanded bits are known one on one side, return the other. // These bits cannot contribute to the result of the 'and'. @@ -1488,7 +1486,7 @@ bool TargetLowering::SimplifyDemandedBits( } return true; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); + if (SimplifyDemandedBits(Op0, ~Known.One & DemandedBits, DemandedElts, Known2, TLO, Depth + 1)) { if (Flags.hasDisjoint()) { @@ -1497,7 +1495,6 @@ bool TargetLowering::SimplifyDemandedBits( } return true; } - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // If all of the demanded bits are known zero on one side, return the other. // These bits cannot contribute to the result of the 'or'. @@ -1563,11 +1560,9 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op1, DemandedBits, DemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); if (SimplifyDemandedBits(Op0, DemandedBits, DemandedElts, Known2, TLO, Depth + 1)) return true; - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // If all of the demanded bits are known zero on one side, return the other. // These bits cannot contribute to the result of the 'xor'. @@ -1663,8 +1658,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op.getOperand(1), DemandedBits, DemandedElts, Known2, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // If the operands are constants, see if we can simplify them. if (ShrinkDemandedConstant(Op, DemandedBits, DemandedElts, TLO)) @@ -1680,8 +1673,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op.getOperand(1), DemandedBits, DemandedElts, Known2, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // Only known if known in both the LHS and RHS. Known = Known.intersectWith(Known2); @@ -1693,8 +1684,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op.getOperand(2), DemandedBits, DemandedElts, Known2, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // If the operands are constants, see if we can simplify them. if (ShrinkDemandedConstant(Op, DemandedBits, DemandedElts, TLO)) @@ -1819,7 +1808,6 @@ bool TargetLowering::SimplifyDemandedBits( } return true; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero <<= ShAmt; Known.One <<= ShAmt; // low bits known zero. @@ -1993,7 +1981,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op0, InDemandedMask, DemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero.lshrInPlace(ShAmt); Known.One.lshrInPlace(ShAmt); // High bits known zero. @@ -2090,7 +2077,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op0, InDemandedMask, DemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero.lshrInPlace(ShAmt); Known.One.lshrInPlace(ShAmt); @@ -2385,7 +2371,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op0, InputDemandedBits, DemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); // If the sign bit of the input is known set or clear, then we know the // top bits of the result. @@ -2458,7 +2443,6 @@ bool TargetLowering::SimplifyDemandedBits( } return true; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); assert(Known.getBitWidth() == InBits && "Src width has changed?"); Known = Known.zext(BitWidth); @@ -2508,7 +2492,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Src, InDemandedBits, InDemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); assert(Known.getBitWidth() == InBits && "Src width has changed?"); // If the sign bit is known one, the top bits match. @@ -2554,7 +2537,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Src, InDemandedBits, InDemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); assert(Known.getBitWidth() == InBits && "Src width has changed?"); Known = Known.anyext(BitWidth); @@ -2620,7 +2602,6 @@ bool TargetLowering::SimplifyDemandedBits( break; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); break; } case ISD::AssertZext: { @@ -2631,7 +2612,6 @@ bool TargetLowering::SimplifyDemandedBits( if (SimplifyDemandedBits(Op.getOperand(0), ~InMask | DemandedBits, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero |= ~InMask; Known.One &= (~Known.Zero); diff --git a/llvm/lib/IR/ConstantRange.cpp b/llvm/lib/IR/ConstantRange.cpp index c3bde48b982ce..08041c96ffe5a 100644 --- a/llvm/lib/IR/ConstantRange.cpp +++ b/llvm/lib/IR/ConstantRange.cpp @@ -58,8 +58,8 @@ ConstantRange::ConstantRange(APInt L, APInt U) ConstantRange ConstantRange::fromKnownBits(const KnownBits &Known, bool IsSigned) { - assert(!Known.hasConflict() && "Expected valid KnownBits"); - + if (Known.hasConflict()) + return getEmpty(Known.getBitWidth()); if (Known.isUnknown()) return getFull(Known.getBitWidth()); diff --git a/llvm/lib/Support/KnownBits.cpp b/llvm/lib/Support/KnownBits.cpp index d6012a8eea8a6..e3ad1468874cd 100644 --- a/llvm/lib/Support/KnownBits.cpp +++ b/llvm/lib/Support/KnownBits.cpp @@ -18,11 +18,8 @@ using namespace llvm; -static KnownBits computeForAddCarry( - const KnownBits &LHS, const KnownBits &RHS, - bool CarryZero, bool CarryOne) { - assert(!(CarryZero && CarryOne) && - "Carry can't be zero and one at the same time"); +static KnownBits computeForAddCarry(const KnownBits &LHS, const KnownBits &RHS, + bool CarryZero, bool CarryOne) { APInt PossibleSumZero = LHS.getMaxValue() + RHS.getMaxValue() + !CarryZero; APInt PossibleSumOne = LHS.getMinValue() + RHS.getMinValue() + CarryOne; @@ -37,9 +34,6 @@ static KnownBits computeForAddCarry( APInt CarryKnownUnion = std::move(CarryKnownZero) | CarryKnownOne; APInt Known = std::move(LHSKnownUnion) & RHSKnownUnion & CarryKnownUnion; - assert((PossibleSumZero & Known) == (PossibleSumOne & Known) && - "known bits of sum differ"); - // Compute known bits of the result. KnownBits KnownOut; KnownOut.Zero = ~std::move(PossibleSumZero) & Known; @@ -608,14 +602,12 @@ KnownBits KnownBits::abs(bool IntMinIsPoison) const { } } - assert(!KnownAbs.hasConflict() && "Bad Output"); return KnownAbs; } static KnownBits computeForSatAddSub(bool Add, bool Signed, const KnownBits &LHS, const KnownBits &RHS) { - assert(!LHS.hasConflict() && !RHS.hasConflict() && "Bad inputs"); // We don't see NSW even for sadd/ssub as we want to check if the result has // signed overflow. KnownBits Res = @@ -715,7 +707,6 @@ static KnownBits computeForSatAddSub(bool Add, bool Signed, // We know whether or not we overflowed. if (!(*Overflow)) { // No overflow. - assert(!Res.hasConflict() && "Bad Output"); return Res; } @@ -737,7 +728,6 @@ static KnownBits computeForSatAddSub(bool Add, bool Signed, Res.One = C; Res.Zero = ~C; - assert(!Res.hasConflict() && "Bad Output"); return Res; } @@ -757,7 +747,6 @@ static KnownBits computeForSatAddSub(bool Add, bool Signed, Res.One.clearAllBits(); } - assert(!Res.hasConflict() && "Bad Output"); return Res; } @@ -808,8 +797,7 @@ KnownBits KnownBits::avgCeilU(const KnownBits &LHS, const KnownBits &RHS) { KnownBits KnownBits::mul(const KnownBits &LHS, const KnownBits &RHS, bool NoUndefSelfMultiply) { unsigned BitWidth = LHS.getBitWidth(); - assert(BitWidth == RHS.getBitWidth() && !LHS.hasConflict() && - !RHS.hasConflict() && "Operand mismatch"); + assert(BitWidth == RHS.getBitWidth() && "Operand mismatch"); assert((!NoUndefSelfMultiply || LHS == RHS) && "Self multiplication knownbits mismatch"); @@ -905,8 +893,7 @@ KnownBits KnownBits::mul(const KnownBits &LHS, const KnownBits &RHS, KnownBits KnownBits::mulhs(const KnownBits &LHS, const KnownBits &RHS) { unsigned BitWidth = LHS.getBitWidth(); - assert(BitWidth == RHS.getBitWidth() && !LHS.hasConflict() && - !RHS.hasConflict() && "Operand mismatch"); + assert(BitWidth == RHS.getBitWidth() && "Operand mismatch"); KnownBits WideLHS = LHS.sext(2 * BitWidth); KnownBits WideRHS = RHS.sext(2 * BitWidth); return mul(WideLHS, WideRHS).extractBits(BitWidth, BitWidth); @@ -914,8 +901,7 @@ KnownBits KnownBits::mulhs(const KnownBits &LHS, const KnownBits &RHS) { KnownBits KnownBits::mulhu(const KnownBits &LHS, const KnownBits &RHS) { unsigned BitWidth = LHS.getBitWidth(); - assert(BitWidth == RHS.getBitWidth() && !LHS.hasConflict() && - !RHS.hasConflict() && "Operand mismatch"); + assert(BitWidth == RHS.getBitWidth() && "Operand mismatch"); KnownBits WideLHS = LHS.zext(2 * BitWidth); KnownBits WideRHS = RHS.zext(2 * BitWidth); return mul(WideLHS, WideRHS).extractBits(BitWidth, BitWidth); @@ -964,7 +950,6 @@ KnownBits KnownBits::sdiv(const KnownBits &LHS, const KnownBits &RHS, return udiv(LHS, RHS, Exact); unsigned BitWidth = LHS.getBitWidth(); - assert(!LHS.hasConflict() && !RHS.hasConflict() && "Bad inputs"); KnownBits Known(BitWidth); if (LHS.isZero() || RHS.isZero()) { @@ -1011,15 +996,12 @@ KnownBits KnownBits::sdiv(const KnownBits &LHS, const KnownBits &RHS, } Known = divComputeLowBit(Known, LHS, RHS, Exact); - - assert(!Known.hasConflict() && "Bad Output"); return Known; } KnownBits KnownBits::udiv(const KnownBits &LHS, const KnownBits &RHS, bool Exact) { unsigned BitWidth = LHS.getBitWidth(); - assert(!LHS.hasConflict() && !RHS.hasConflict()); KnownBits Known(BitWidth); if (LHS.isZero() || RHS.isZero()) { @@ -1041,7 +1023,6 @@ KnownBits KnownBits::udiv(const KnownBits &LHS, const KnownBits &RHS, Known.Zero.setHighBits(LeadZ); Known = divComputeLowBit(Known, LHS, RHS, Exact); - assert(!Known.hasConflict() && "Bad Output"); return Known; } @@ -1059,8 +1040,6 @@ KnownBits KnownBits::remGetLowBits(const KnownBits &LHS, const KnownBits &RHS) { } KnownBits KnownBits::urem(const KnownBits &LHS, const KnownBits &RHS) { - assert(!LHS.hasConflict() && !RHS.hasConflict()); - KnownBits Known = remGetLowBits(LHS, RHS); if (RHS.isConstant() && RHS.getConstant().isPowerOf2()) { // NB: Low bits set in `remGetLowBits`. @@ -1078,8 +1057,6 @@ KnownBits KnownBits::urem(const KnownBits &LHS, const KnownBits &RHS) { } KnownBits KnownBits::srem(const KnownBits &LHS, const KnownBits &RHS) { - assert(!LHS.hasConflict() && !RHS.hasConflict()); - KnownBits Known = remGetLowBits(LHS, RHS); if (RHS.isConstant() && RHS.getConstant().isPowerOf2()) { // NB: Low bits are set in `remGetLowBits`. diff --git a/llvm/lib/Target/X86/X86ISelLowering.cpp b/llvm/lib/Target/X86/X86ISelLowering.cpp index af1e45d25aac4..0882ea3fdaca3 100644 --- a/llvm/lib/Target/X86/X86ISelLowering.cpp +++ b/llvm/lib/Target/X86/X86ISelLowering.cpp @@ -42445,12 +42445,10 @@ bool X86TargetLowering::SimplifyDemandedBitsForTargetNode( if (SimplifyDemandedBits(Op1, OriginalDemandedBits, OriginalDemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); if (SimplifyDemandedBits(Op0, ~Known.Zero & OriginalDemandedBits, OriginalDemandedElts, Known2, TLO, Depth + 1)) return true; - assert(!Known2.hasConflict() && "Bits known to be one AND zero?"); // If the RHS is a constant, see if we can simplify it. if (ShrinkDemandedConstant(Op, ~Known2.One & OriginalDemandedBits, @@ -42501,7 +42499,6 @@ bool X86TargetLowering::SimplifyDemandedBitsForTargetNode( TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero <<= ShAmt; Known.One <<= ShAmt; @@ -42520,7 +42517,6 @@ bool X86TargetLowering::SimplifyDemandedBitsForTargetNode( OriginalDemandedElts, Known, TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero.lshrInPlace(ShAmt); Known.One.lshrInPlace(ShAmt); @@ -42561,7 +42557,6 @@ bool X86TargetLowering::SimplifyDemandedBitsForTargetNode( TLO, Depth + 1)) return true; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero.lshrInPlace(ShAmt); Known.One.lshrInPlace(ShAmt); diff --git a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp index 6739b8745d74e..b3eebee0d0d8c 100644 --- a/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp +++ b/llvm/lib/Transforms/InstCombine/InstCombineSimplifyDemanded.cpp @@ -209,8 +209,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, SimplifyDemandedBits(I, 0, DemandedMask & ~RHSKnown.Zero, LHSKnown, Depth + 1)) return I; - assert(!RHSKnown.hasConflict() && "Bits known to be one AND zero?"); - assert(!LHSKnown.hasConflict() && "Bits known to be one AND zero?"); Known = analyzeKnownBitsFromAndXorOr(cast(I), LHSKnown, RHSKnown, Depth, SQ.getWithInstruction(CxtI)); @@ -242,8 +240,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, I->dropPoisonGeneratingFlags(); return I; } - assert(!RHSKnown.hasConflict() && "Bits known to be one AND zero?"); - assert(!LHSKnown.hasConflict() && "Bits known to be one AND zero?"); Known = analyzeKnownBitsFromAndXorOr(cast(I), LHSKnown, RHSKnown, Depth, SQ.getWithInstruction(CxtI)); @@ -291,9 +287,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, return Builder.CreateUnaryIntrinsic(Intrinsic::ctpop, Xor); } - assert(!RHSKnown.hasConflict() && "Bits known to be one AND zero?"); - assert(!LHSKnown.hasConflict() && "Bits known to be one AND zero?"); - Known = analyzeKnownBitsFromAndXorOr(cast(I), LHSKnown, RHSKnown, Depth, SQ.getWithInstruction(CxtI)); @@ -375,8 +368,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, if (SimplifyDemandedBits(I, 2, DemandedMask, RHSKnown, Depth + 1) || SimplifyDemandedBits(I, 1, DemandedMask, LHSKnown, Depth + 1)) return I; - assert(!RHSKnown.hasConflict() && "Bits known to be one AND zero?"); - assert(!LHSKnown.hasConflict() && "Bits known to be one AND zero?"); // If the operands are constants, see if we can simplify them. // This is similar to ShrinkDemandedConstant, but for a select we want to @@ -455,7 +446,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, InputKnown.makeNonNegative(); Known = InputKnown.zextOrTrunc(BitWidth); - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); break; } case Instruction::SExt: { @@ -481,12 +471,11 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, CastInst *NewCast = new ZExtInst(I->getOperand(0), VTy); NewCast->takeName(I); return InsertNewInstWith(NewCast, I->getIterator()); - } + } // If the sign bit of the input is known set or clear, then we know the // top bits of the result. Known = InputKnown.sext(BitWidth); - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); break; } case Instruction::Add: { @@ -696,7 +685,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, if (SimplifyDemandedBits(I, 0, DemandedMaskIn, Known, Depth + 1)) return I; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known = KnownBits::shl(Known, KnownBits::makeConstant(APInt(BitWidth, ShiftAmt)), @@ -772,7 +760,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, I->dropPoisonGeneratingFlags(); return I; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); Known.Zero.lshrInPlace(ShiftAmt); Known.One.lshrInPlace(ShiftAmt); if (ShiftAmt) @@ -819,7 +806,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, return I; } - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); // Compute the new bits that are at the top now plus sign bits. APInt HighBits(APInt::getHighBitsSet( BitWidth, std::min(SignBits + ShiftAmt - 1, BitWidth))); @@ -900,7 +886,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, if (LHSKnown.isNegative() && LowBits.intersects(LHSKnown.One)) Known.One |= ~LowBits; - assert(!Known.hasConflict() && "Bits known to be one AND zero?"); break; } } @@ -978,8 +963,6 @@ Value *InstCombinerImpl::SimplifyDemandedUseBits(Value *V, APInt DemandedMask, // TODO: Should be 1-extend RHSKnown = RHSKnown.anyextOrTrunc(BitWidth); - assert(!RHSKnown.hasConflict() && "Bits known to be one AND zero?"); - assert(!LHSKnown.hasConflict() && "Bits known to be one AND zero?"); Known = LHSKnown & RHSKnown; KnownBitsComputed = true; diff --git a/llvm/unittests/IR/DemandedBitsTest.cpp b/llvm/unittests/IR/DemandedBitsTest.cpp index 4d15e81899612..b52173412a99a 100644 --- a/llvm/unittests/IR/DemandedBitsTest.cpp +++ b/llvm/unittests/IR/DemandedBitsTest.cpp @@ -38,8 +38,10 @@ static void TestBinOpExhaustive(Fn1 PropagateFn, Fn2 EvalFn) { APInt AB1R = PropagateFn(0, AOut, Known1Redacted, Known2Redacted); APInt AB2R = PropagateFn(1, AOut, Known1Redacted, Known2Redacted); - EXPECT_EQ(AB1, AB1R); - EXPECT_EQ(AB2, AB2R); + if (!Known1Redacted.hasConflict() && !Known2Redacted.hasConflict()) { + EXPECT_EQ(AB1, AB1R); + EXPECT_EQ(AB2, AB2R); + } } ForeachNumInKnownBits(Known1, [&](APInt Value1) { ForeachNumInKnownBits(Known2, [&](APInt Value2) { diff --git a/llvm/unittests/Support/KnownBitsTest.cpp b/llvm/unittests/Support/KnownBitsTest.cpp index 824cf7501fd44..51e780c42af27 100644 --- a/llvm/unittests/Support/KnownBitsTest.cpp +++ b/llvm/unittests/Support/KnownBitsTest.cpp @@ -68,16 +68,16 @@ static void testUnaryOpExhaustive(StringRef Name, UnaryBitsFn BitsFn, } }); - EXPECT_TRUE(!Computed.hasConflict()); - EXPECT_TRUE(checkResult(Name, Exact, Computed, Known, CheckOptimality)); + if (!Exact.hasConflict()) { + EXPECT_TRUE(checkResult(Name, Exact, Computed, Known, CheckOptimality)); + } }); } } static void testBinaryOpExhaustive(StringRef Name, BinaryBitsFn BitsFn, BinaryIntFn IntFn, - bool CheckOptimality = true, - bool RefinePoisonToZero = false) { + bool CheckOptimality = true) { for (unsigned Bits : {1, 4}) { ForeachKnownBits(Bits, [&](const KnownBits &Known1) { ForeachKnownBits(Bits, [&](const KnownBits &Known2) { @@ -95,13 +95,9 @@ static void testBinaryOpExhaustive(StringRef Name, BinaryBitsFn BitsFn, }); }); - EXPECT_TRUE(!Computed.hasConflict()); - EXPECT_TRUE(checkResult(Name, Exact, Computed, {Known1, Known2}, - CheckOptimality)); - // In some cases we choose to return zero if the result is always - // poison. - if (RefinePoisonToZero && Exact.hasConflict()) { - EXPECT_TRUE(Computed.isZero()); + if (!Exact.hasConflict()) { + EXPECT_TRUE(checkResult(Name, Exact, Computed, {Known1, Known2}, + CheckOptimality)); } }); }); @@ -135,7 +131,9 @@ TEST(KnownBitsTest, AddCarryExhaustive) { KnownBits Computed = KnownBits::computeForAddCarry(Known1, Known2, KnownCarry); - EXPECT_EQ(Exact, Computed); + if (!Exact.hasConflict()) { + EXPECT_EQ(Exact, Computed); + } }); }); }); @@ -246,7 +244,9 @@ TEST(KnownBitsTest, SubBorrowExhaustive) { KnownBits Computed = KnownBits::computeForSubBorrow(Known1, Known2, KnownBorrow); - EXPECT_EQ(Exact, Computed); + if (!Exact.hasConflict()) { + EXPECT_EQ(Exact, Computed); + } }); }); }); @@ -394,7 +394,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return N1.shl(N2); }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "ushl_ov", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -407,7 +407,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return Res; }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "shl nsw", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -420,7 +420,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return Res; }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "shl nuw", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -434,7 +434,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return Res; }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "lshr", @@ -446,7 +446,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return N1.lshr(N2); }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "lshr exact", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -460,7 +460,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return N1.lshr(N2); }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "ashr", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -471,7 +471,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return N1.ashr(N2); }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "ashr exact", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -485,7 +485,7 @@ TEST(KnownBitsTest, BinaryExhaustive) { return std::nullopt; return N1.ashr(N2); }, - /*CheckOptimality=*/true, /* RefinePoisonToZero */ true); + /*CheckOptimality=*/true); testBinaryOpExhaustive( "mul", [](const KnownBits &Known1, const KnownBits &Known2) { @@ -608,6 +608,9 @@ TEST(KnownBitsTest, ICmpExhaustive) { std::optional KnownSLT = KnownBits::slt(Known1, Known2); std::optional KnownSLE = KnownBits::sle(Known1, Known2); + if (Known1.hasConflict() || Known2.hasConflict()) + return; + EXPECT_EQ(AllEQ || NoneEQ, KnownEQ.has_value()); EXPECT_EQ(AllNE || NoneNE, KnownNE.has_value()); EXPECT_EQ(AllUGT || NoneUGT, KnownUGT.has_value()); @@ -653,8 +656,10 @@ TEST(KnownBitsTest, GetMinMaxVal) { Min = APIntOps::umin(Min, N); Max = APIntOps::umax(Max, N); }); - EXPECT_EQ(Min, Known.getMinValue()); - EXPECT_EQ(Max, Known.getMaxValue()); + if (!Known.hasConflict()) { + EXPECT_EQ(Min, Known.getMinValue()); + EXPECT_EQ(Max, Known.getMaxValue()); + } }); } @@ -667,8 +672,10 @@ TEST(KnownBitsTest, GetSignedMinMaxVal) { Min = APIntOps::smin(Min, N); Max = APIntOps::smax(Max, N); }); - EXPECT_EQ(Min, Known.getSignedMinValue()); - EXPECT_EQ(Max, Known.getSignedMaxValue()); + if (!Known.hasConflict()) { + EXPECT_EQ(Min, Known.getSignedMinValue()); + EXPECT_EQ(Max, Known.getSignedMaxValue()); + } }); } @@ -679,7 +686,9 @@ TEST(KnownBitsTest, CountMaxActiveBits) { ForeachNumInKnownBits(Known, [&](const APInt &N) { Expected = std::max(Expected, N.getActiveBits()); }); - EXPECT_EQ(Expected, Known.countMaxActiveBits()); + if (!Known.hasConflict()) { + EXPECT_EQ(Expected, Known.countMaxActiveBits()); + } }); } @@ -690,7 +699,9 @@ TEST(KnownBitsTest, CountMaxSignificantBits) { ForeachNumInKnownBits(Known, [&](const APInt &N) { Expected = std::max(Expected, N.getSignificantBits()); }); - EXPECT_EQ(Expected, Known.countMaxSignificantBits()); + if (!Known.hasConflict()) { + EXPECT_EQ(Expected, Known.countMaxSignificantBits()); + } }); } @@ -736,8 +747,10 @@ TEST(KnownBitsTest, SExtInReg) { CommonZero &= ~Ext; }); KnownBits KnownSExtInReg = Known.sextInReg(FromBits); - EXPECT_EQ(CommonOne, KnownSExtInReg.One); - EXPECT_EQ(CommonZero, KnownSExtInReg.Zero); + if (!Known.hasConflict()) { + EXPECT_EQ(CommonOne, KnownSExtInReg.One); + EXPECT_EQ(CommonZero, KnownSExtInReg.Zero); + } }); } } @@ -752,8 +765,10 @@ TEST(KnownBitsTest, CommonBitsSet) { HasCommonBitsSet |= N1.intersects(N2); }); }); - EXPECT_EQ(!HasCommonBitsSet, - KnownBits::haveNoCommonBitsSet(Known1, Known2)); + if (!Known1.hasConflict() && !Known2.hasConflict()) { + EXPECT_EQ(!HasCommonBitsSet, + KnownBits::haveNoCommonBitsSet(Known1, Known2)); + } }); }); } diff --git a/llvm/unittests/Support/KnownBitsTest.h b/llvm/unittests/Support/KnownBitsTest.h index bc291898814bd..556da2b9ecdad 100644 --- a/llvm/unittests/Support/KnownBitsTest.h +++ b/llvm/unittests/Support/KnownBitsTest.h @@ -26,9 +26,6 @@ template void ForeachKnownBits(unsigned Bits, FnTy Fn) { for (unsigned One = 0; One < Max; ++One) { Known.Zero = Zero; Known.One = One; - if (Known.hasConflict()) - continue; - Fn(Known); } }