[llvm] IR: de-duplicate two CmpInst routines (NFC) (PR #116866)
Ramkumar Ramachandra via llvm-commits
llvm-commits at lists.llvm.org
Tue Nov 19 13:38:06 PST 2024
https://github.com/artagnon updated https://github.com/llvm/llvm-project/pull/116866
>From 2a7d7af1c3345775e80861526ddc8e0d4d868173 Mon Sep 17 00:00:00 2001
From: Ramkumar Ramachandra <ramkumar.ramachandra at codasip.com>
Date: Tue, 19 Nov 2024 15:25:05 +0000
Subject: [PATCH] IR: de-duplicate two CmpInst routines (NFC)
De-duplicate the functions getSignedPredicate and getUnsignedPredicate,
nearly identical versions of which were present in CmpInst and ICmpInst,
creating less confusion.
---
llvm/include/llvm/IR/InstrTypes.h | 37 -------------------
llvm/include/llvm/IR/Instructions.h | 22 ++++++++---
llvm/include/llvm/SandboxIR/Instruction.h | 4 +-
llvm/lib/Analysis/ScalarEvolution.cpp | 2 +-
llvm/lib/CodeGen/ExpandMemCmp.cpp | 2 +-
llvm/lib/IR/ConstantRange.cpp | 5 ++-
llvm/lib/IR/Instructions.cpp | 36 +-----------------
.../Scalar/ConstraintElimination.cpp | 6 +--
8 files changed, 26 insertions(+), 88 deletions(-)
diff --git a/llvm/include/llvm/IR/InstrTypes.h b/llvm/include/llvm/IR/InstrTypes.h
index 1c60eae7f2f85b..e6332a16df7d5f 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 8eea659a00caf3..605964af5d676c 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 d9642365908d28..efa763c485da96 100644
--- a/llvm/include/llvm/SandboxIR/Instruction.h
+++ b/llvm/include/llvm/SandboxIR/Instruction.h
@@ -2501,9 +2501,6 @@ class CmpInst : public SingleLLVMInstructionImpl<llvm::CmpInst> {
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 46b108606f6a62..376f260846bbaa 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 1de01e402e59e6..a1acb4ef368380 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 61a051821a5dbf..d81a292916fdea 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 5b89a27126150a..7350c65b35fb71 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<bool> 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 d2e532d29d07b5..1bfe7fd7d9e7e6 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<Value *> 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;
More information about the llvm-commits
mailing list