diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h index 1c60eae7f2f85..e6332a16df7d5 100644 --- a/llvm/include/llvm/IR/InstrTypes.h +++ b/llvm/include/llvm/IR/InstrTypes.h @@ -935,43 +935,6 @@ class CmpInst : public Instruction { return isUnsigned(getPredicate()); } - /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert - /// @returns the signed version of the unsigned predicate pred. - /// return the signed version of a predicate - static Predicate getSignedPredicate(Predicate pred); - - /// For example, ULT->SLT, ULE->SLE, UGT->SGT, UGE->SGE, SLT->Failed assert - /// @returns the signed version of the predicate for this instruction (which - /// has to be an unsigned predicate). - /// return the signed version of a predicate - Predicate getSignedPredicate() { - return getSignedPredicate(getPredicate()); - } - - /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert - /// @returns the unsigned version of the signed predicate pred. - static Predicate getUnsignedPredicate(Predicate pred); - - /// For example, SLT->ULT, SLE->ULE, SGT->UGT, SGE->UGE, ULT->Failed assert - /// @returns the unsigned version of the predicate for this instruction (which - /// has to be an signed predicate). - /// return the unsigned version of a predicate - Predicate getUnsignedPredicate() { - return getUnsignedPredicate(getPredicate()); - } - - /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert - /// @returns the unsigned version of the signed predicate pred or - /// the signed version of the signed predicate pred. - static Predicate getFlippedSignednessPredicate(Predicate pred); - - /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert - /// @returns the unsigned version of the signed predicate pred or - /// the signed version of the signed predicate pred. - Predicate getFlippedSignednessPredicate() { - return getFlippedSignednessPredicate(getPredicate()); - } - /// This is just a convenience. /// Determine if this is true when both operands are the same. bool isTrueWhenEqual() const { diff --git a/llvm/include/llvm/IR/Instructions.h b/llvm/include/llvm/IR/Instructions.h index 8eea659a00caf..605964af5d676 100644 --- a/llvm/include/llvm/IR/Instructions.h +++ b/llvm/include/llvm/IR/Instructions.h @@ -1206,27 +1206,37 @@ class ICmpInst: public CmpInst { /// For example, EQ->EQ, SLE->SLE, UGT->SGT, etc. /// @returns the predicate that would be the result if the operand were /// regarded as signed. - /// Return the signed version of the predicate + /// Return the signed version of the predicate. Predicate getSignedPredicate() const { return getSignedPredicate(getPredicate()); } - /// This is a static version that you can use without an instruction. - /// Return the signed version of the predicate. + /// Return the signed version of the predicate: static variant. static Predicate getSignedPredicate(Predicate pred); /// For example, EQ->EQ, SLE->ULE, UGT->UGT, etc. /// @returns the predicate that would be the result if the operand were /// regarded as unsigned. - /// Return the unsigned version of the predicate + /// Return the unsigned version of the predicate. Predicate getUnsignedPredicate() const { return getUnsignedPredicate(getPredicate()); } - /// This is a static version that you can use without an instruction. - /// Return the unsigned version of the predicate. + /// Return the unsigned version of the predicate: static variant. static Predicate getUnsignedPredicate(Predicate pred); + /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert + /// @returns the unsigned version of the signed predicate pred or + /// the signed version of the signed predicate pred. + static Predicate getFlippedSignednessPredicate(Predicate pred); + + /// For example, SLT->ULT, ULT->SLT, SLE->ULE, ULE->SLE, EQ->Failed assert + /// @returns the unsigned version of the signed predicate pred or + /// the signed version of the signed predicate pred. + Predicate getFlippedSignednessPredicate() const { + return getFlippedSignednessPredicate(getPredicate()); + } + void setSameSign(bool B = true) { SubclassOptionalData = (SubclassOptionalData & ~SameSign) | (B * SameSign); } diff --git a/llvm/include/llvm/SandboxIR/Instruction.h b/llvm/include/llvm/SandboxIR/Instruction.h index d9642365908d2..efa763c485da9 100644 --- a/llvm/include/llvm/SandboxIR/Instruction.h +++ b/llvm/include/llvm/SandboxIR/Instruction.h @@ -2501,9 +2501,6 @@ class CmpInst : public SingleLLVMInstructionImpl { WRAP_BOTH(isEquality); WRAP_BOTH(isRelational); WRAP_BOTH(isSigned); - WRAP_BOTH(getSignedPredicate); - WRAP_BOTH(getUnsignedPredicate); - WRAP_BOTH(getFlippedSignednessPredicate); WRAP_BOTH(isTrueWhenEqual); WRAP_BOTH(isFalseWhenEqual); WRAP_BOTH(isUnsigned); @@ -2544,6 +2541,7 @@ class ICmpInst : public CmpInst { WRAP_BOTH(getSignedPredicate); WRAP_BOTH(getUnsignedPredicate); + WRAP_BOTH(getFlippedSignednessPredicate); WRAP_BOTH(isEquality); WRAP_MEMBER(isCommutative); WRAP_MEMBER(isRelational); diff --git a/llvm/lib/Analysis/ScalarEvolution.cpp b/llvm/lib/Analysis/ScalarEvolution.cpp index 46b108606f6a6..376f260846bba 100644 --- a/llvm/lib/Analysis/ScalarEvolution.cpp +++ b/llvm/lib/Analysis/ScalarEvolution.cpp @@ -11874,7 +11874,7 @@ bool ScalarEvolution::isImpliedCondBalancedTypes( CmpInst::Predicate P2) { assert(P1 != P2 && "Handled earlier!"); return CmpInst::isRelational(P2) && - P1 == CmpInst::getFlippedSignednessPredicate(P2); + P1 == ICmpInst::getFlippedSignednessPredicate(P2); }; if (IsSignFlippedPredicate(Pred, FoundPred)) { // Unsigned comparison is the same as signed comparison when both the diff --git a/llvm/lib/CodeGen/ExpandMemCmp.cpp b/llvm/lib/CodeGen/ExpandMemCmp.cpp index 1de01e402e59e..a1acb4ef36838 100644 --- a/llvm/lib/CodeGen/ExpandMemCmp.cpp +++ b/llvm/lib/CodeGen/ExpandMemCmp.cpp @@ -686,7 +686,7 @@ Value *MemCmpExpansion::getMemCmpOneBlock() { } // Generate new code and remove the original memcmp call and the user if (ICmpInst::isSigned(Pred)) { - Value *Cmp = Builder.CreateICmp(CmpInst::getUnsignedPredicate(Pred), + Value *Cmp = Builder.CreateICmp(ICmpInst::getUnsignedPredicate(Pred), Loads.Lhs, Loads.Rhs); auto *Result = NeedsZExt ? Builder.CreateZExt(Cmp, UI->getType()) : Cmp; UI->replaceAllUsesWith(Result); diff --git a/llvm/lib/IR/ConstantRange.cpp b/llvm/lib/IR/ConstantRange.cpp index 61a051821a5db..d81a292916fde 100644 --- a/llvm/lib/IR/ConstantRange.cpp +++ b/llvm/lib/IR/ConstantRange.cpp @@ -20,12 +20,13 @@ // //===----------------------------------------------------------------------===// +#include "llvm/IR/ConstantRange.h" #include "llvm/ADT/APInt.h" #include "llvm/Config/llvm-config.h" -#include "llvm/IR/ConstantRange.h" #include "llvm/IR/Constants.h" #include "llvm/IR/InstrTypes.h" #include "llvm/IR/Instruction.h" +#include "llvm/IR/Instructions.h" #include "llvm/IR/Intrinsics.h" #include "llvm/IR/Metadata.h" #include "llvm/IR/Operator.h" @@ -191,7 +192,7 @@ CmpInst::Predicate ConstantRange::getEquivalentPredWithFlippedSignedness( "Only for relational integer predicates!"); CmpInst::Predicate FlippedSignednessPred = - CmpInst::getFlippedSignednessPredicate(Pred); + ICmpInst::getFlippedSignednessPredicate(Pred); if (areInsensitiveToSignednessOfICmpPredicate(CR1, CR2)) return FlippedSignednessPred; diff --git a/llvm/lib/IR/Instructions.cpp b/llvm/lib/IR/Instructions.cpp index 5b89a27126150..7350c65b35fb7 100644 --- a/llvm/lib/IR/Instructions.cpp +++ b/llvm/lib/IR/Instructions.cpp @@ -3718,40 +3718,6 @@ CmpInst::Predicate CmpInst::getFlippedStrictnessPredicate(Predicate pred) { llvm_unreachable("Unknown predicate!"); } -CmpInst::Predicate CmpInst::getSignedPredicate(Predicate pred) { - assert(CmpInst::isUnsigned(pred) && "Call only with unsigned predicates!"); - - switch (pred) { - default: - llvm_unreachable("Unknown predicate!"); - case CmpInst::ICMP_ULT: - return CmpInst::ICMP_SLT; - case CmpInst::ICMP_ULE: - return CmpInst::ICMP_SLE; - case CmpInst::ICMP_UGT: - return CmpInst::ICMP_SGT; - case CmpInst::ICMP_UGE: - return CmpInst::ICMP_SGE; - } -} - -CmpInst::Predicate CmpInst::getUnsignedPredicate(Predicate pred) { - assert(CmpInst::isSigned(pred) && "Call only with signed predicates!"); - - switch (pred) { - default: - llvm_unreachable("Unknown predicate!"); - case CmpInst::ICMP_SLT: - return CmpInst::ICMP_ULT; - case CmpInst::ICMP_SLE: - return CmpInst::ICMP_ULE; - case CmpInst::ICMP_SGT: - return CmpInst::ICMP_UGT; - case CmpInst::ICMP_SGE: - return CmpInst::ICMP_UGE; - } -} - bool CmpInst::isUnsigned(Predicate predicate) { switch (predicate) { default: return false; @@ -3867,7 +3833,7 @@ std::optional ICmpInst::compare(const KnownBits &LHS, } } -CmpInst::Predicate CmpInst::getFlippedSignednessPredicate(Predicate pred) { +CmpInst::Predicate ICmpInst::getFlippedSignednessPredicate(Predicate pred) { assert(CmpInst::isRelational(pred) && "Call only with non-equality predicates!"); diff --git a/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp b/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp index d2e532d29d07b..1bfe7fd7d9e7e 100644 --- a/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp +++ b/llvm/lib/Transforms/Scalar/ConstraintElimination.cpp @@ -767,7 +767,7 @@ ConstraintTy ConstraintInfo::getConstraintForSolving(CmpInst::Predicate Pred, if (CmpInst::isSigned(Pred) && isKnownNonNegative(Op0, DL, /*Depth=*/MaxAnalysisRecursionDepth - 1) && isKnownNonNegative(Op1, DL, /*Depth=*/MaxAnalysisRecursionDepth - 1)) - Pred = CmpInst::getUnsignedPredicate(Pred); + Pred = ICmpInst::getUnsignedPredicate(Pred); SmallVector NewVariables; ConstraintTy R = getConstraint(Pred, Op0, Op1, NewVariables); @@ -857,7 +857,7 @@ void ConstraintInfo::transferToOtherSystem( if (IsKnownNonNegative(B)) { addFact(CmpInst::ICMP_SGE, A, ConstantInt::get(B->getType(), 0), NumIn, NumOut, DFSInStack); - addFact(CmpInst::getSignedPredicate(Pred), A, B, NumIn, NumOut, + addFact(ICmpInst::getSignedPredicate(Pred), A, B, NumIn, NumOut, DFSInStack); } break; @@ -867,7 +867,7 @@ void ConstraintInfo::transferToOtherSystem( if (IsKnownNonNegative(A)) { addFact(CmpInst::ICMP_SGE, B, ConstantInt::get(B->getType(), 0), NumIn, NumOut, DFSInStack); - addFact(CmpInst::getSignedPredicate(Pred), A, B, NumIn, NumOut, + addFact(ICmpInst::getSignedPredicate(Pred), A, B, NumIn, NumOut, DFSInStack); } break;