[llvm] [SandboxIR] Implement CmpInst, FCmpInst, and ICmpInst (PR #106301)
via llvm-commits
llvm-commits at lists.llvm.org
Tue Aug 27 15:55:42 PDT 2024
https://github.com/Sterling-Augustine created https://github.com/llvm/llvm-project/pull/106301
As in the description.
Not sure the macros for "WRAP_XXX" add value or not, but do save some boiler plate. Maybe there is a better way.
>From e91c6ce666144c102e889f51c13fa13bacead8a9 Mon Sep 17 00:00:00 2001
From: Sterling Augustine <saugustine at google.com>
Date: Thu, 8 Aug 2024 23:08:25 +0000
Subject: [PATCH] [SandboxIR] Implement CmpInst, FCmpInst, and ICmpInst
---
llvm/include/llvm/SandboxIR/SandboxIR.h | 212 +++++++++++++++++-
.../llvm/SandboxIR/SandboxIRValues.def | 3 +
llvm/include/llvm/SandboxIR/Tracker.h | 28 +++
llvm/lib/SandboxIR/SandboxIR.cpp | 62 +++++
llvm/lib/SandboxIR/Tracker.cpp | 18 ++
llvm/unittests/SandboxIR/SandboxIRTest.cpp | 127 +++++++++++
llvm/unittests/SandboxIR/TrackerTest.cpp | 43 ++++
7 files changed, 488 insertions(+), 5 deletions(-)
diff --git a/llvm/include/llvm/SandboxIR/SandboxIR.h b/llvm/include/llvm/SandboxIR/SandboxIR.h
index b7bdf9acd2ef45..b47b6ee512471e 100644
--- a/llvm/include/llvm/SandboxIR/SandboxIR.h
+++ b/llvm/include/llvm/SandboxIR/SandboxIR.h
@@ -54,11 +54,17 @@
// | |
// | +- ZExtInst
// |
-// +- CallBase -----------+- CallBrInst
-// | |
-// +- CmpInst +- CallInst
-// | |
-// +- ExtractElementInst +- InvokeInst
+// +- CallBase --------+- CallBrInst
+// | |
+// | +- CallInst
+// | |
+// | +- InvokeInst
+// |
+// +- CmpInst ---------+- ICmpInst
+// | |
+// | +- FCmpInst
+// |
+// +- ExtractElementInst
// |
// +- GetElementPtrInst
// |
@@ -150,6 +156,9 @@ class BinaryOperator;
class PossiblyDisjointInst;
class AtomicRMWInst;
class AtomicCmpXchgInst;
+class CmpInst;
+class ICmpInst;
+class FCmpInst;
/// Iterator for the `Use` edges of a User's operands.
/// \Returns the operand `Use` when dereferenced.
@@ -294,6 +303,9 @@ class Value {
friend class PHINode; // For getting `Val`.
friend class UnreachableInst; // For getting `Val`.
friend class CatchSwitchAddHandler; // For `Val`.
+ friend class CmpInst; // For getting `Val`.
+ friend class ICmpInst; // For getting `Val`.
+ friend class FCmpInst; // For getting `Val`.
/// All values point to the context.
Context &Ctx;
@@ -730,6 +742,9 @@ class Instruction : public sandboxir::User {
friend class CastInst; // For getTopmostLLVMInstruction().
friend class PHINode; // For getTopmostLLVMInstruction().
friend class UnreachableInst; // For getTopmostLLVMInstruction().
+ friend class CmpInst; // For getTopmostLLVMInstruction().
+ friend class ICmpInst; // For getTopmostLLVMInstruction().
+ friend class FCmpInst; // For getTopmostLLVMInstruction().
/// \Returns the LLVM IR Instructions that this SandboxIR maps to in program
/// order.
@@ -2974,6 +2989,187 @@ class PHINode final : public SingleLLVMInstructionImpl<llvm::PHINode> {
// uint32_t ToIdx = 0)
};
+// Wraps a static function that takes a single Predicate parameter
+// LLVMValType should be the type of the wrapped class
+#define WRAP_STATIC_PREDICATE(FunctionName) \
+ static auto FunctionName(Predicate P) { return LLVMValType::FunctionName(P); }
+// Wraps a member function that takes no parameters
+// LLVMValType should be the type of the wrapped class
+#define WRAP_MEMBER(FunctionName) \
+ auto FunctionName() { return cast<LLVMValType>(Val)->FunctionName(); }
+// Wraps both--a common idiom in the CmpInst classes
+#define WRAP_BOTH(FunctionName) \
+ WRAP_STATIC_PREDICATE(FunctionName) \
+ WRAP_MEMBER(FunctionName)
+
+class CmpInst : public Instruction {
+protected:
+ using LLVMValType = llvm::CmpInst;
+ /// Use Context::createCmpInst(). Don't call the
+ /// constructor directly.
+ CmpInst(llvm::CmpInst *CI, Context &Ctx, ClassID Id = ClassID::Cmp,
+ Opcode Opc = Opcode::Cmp)
+ : Instruction(Id, Opc, CI, Ctx) {}
+ friend Context; // for CmpInst()
+ Use getOperandUseInternal(unsigned OpIdx, bool Verify) const final {
+ return getOperandUseDefault(OpIdx, Verify);
+ }
+ SmallVector<llvm::Instruction *, 1> getLLVMInstrs() const final {
+ return {cast<llvm::Instruction>(Val)};
+ }
+ static Value *createCommon(Value *Cond, Value *True, Value *False,
+ const Twine &Name, IRBuilder<> &Builder,
+ Context &Ctx);
+
+public:
+ using Predicate = llvm::CmpInst::Predicate;
+ using PredicateField = llvm::CmpInst::PredicateField;
+ using OtherOps = llvm::Instruction::OtherOps;
+
+ unsigned getUseOperandNo(const Use &Use) const final {
+ return getUseOperandNoDefault(Use);
+ }
+ unsigned getNumOfIRInstrs() const final { return 1u; }
+ static CmpInst *create(OtherOps Op, Predicate Pred, Value *S1, Value *S2,
+ const Twine &Name = "",
+ InsertPosition InsertBefore = nullptr);
+ static CmpInst *CreateWithCopiedFlags(OtherOps Op, Predicate Pred, Value *S1,
+ Value *S2,
+ const Instruction *FlagsSource,
+ const Twine &Name = "",
+ InsertPosition InsertBefore = nullptr);
+ OtherOps getOpcode() const {
+ return static_cast<OtherOps>(Instruction::getOpcode());
+ }
+ void setPredicate(Predicate P);
+ void swapOperands();
+
+ WRAP_MEMBER(getPredicate);
+ WRAP_BOTH(isFPPredicate);
+ WRAP_BOTH(isIntPredicate);
+ WRAP_STATIC_PREDICATE(getPredicateName);
+ WRAP_BOTH(getInversePredicate);
+ WRAP_BOTH(getOrderedPredicate);
+ WRAP_BOTH(getUnorderedPredicate);
+ WRAP_BOTH(getSwappedPredicate);
+ WRAP_BOTH(isStrictPredicate);
+ WRAP_BOTH(isNonStrictPredicate);
+ WRAP_BOTH(getStrictPredicate);
+ WRAP_BOTH(getNonStrictPredicate);
+ WRAP_BOTH(getFlippedStrictnessPredicate);
+ WRAP_MEMBER(isCommutative);
+ 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);
+ WRAP_STATIC_PREDICATE(isOrdered);
+ WRAP_STATIC_PREDICATE(isUnordered);
+
+ static bool isImpliedTrueByMatchingCmp(Predicate Pred1, Predicate Pred2) {
+ return llvm::CmpInst::isImpliedTrueByMatchingCmp(Pred1, Pred2);
+ }
+ static bool isImpliedFalseByMatchingCmp(Predicate Pred1, Predicate Pred2) {
+ return llvm::CmpInst::isImpliedFalseByMatchingCmp(Pred1, Pred2);
+ }
+
+ /// Methods for support type inquiry through isa, cast, and dyn_cast:
+ static bool classof(const Instruction *From) {
+ return isa<ICmpInst>(From) || isa<FCmpInst>(From);
+ }
+ static bool classof(const Value *From) {
+ return isa<Instruction>(From) && classof(cast<Instruction>(From));
+ }
+ /// Create a result type for fcmp/icmp
+ static Type *makeCmpResultType(Type *opnd_type) {
+ if (VectorType *vt = dyn_cast<VectorType>(opnd_type)) {
+ return VectorType::get(Type::getInt1Ty(opnd_type->getContext()),
+ vt->getElementCount());
+ }
+ return Type::getInt1Ty(opnd_type->getContext());
+ }
+
+#ifndef NDEBUG
+ void verify() const final {
+ assert(isa<LLVMValType>(Val) && "Expected CmpInst!");
+ }
+ void dumpOS(raw_ostream &OS) const override;
+ LLVM_DUMP_METHOD void dump() const;
+#endif
+};
+
+class ICmpInst : public CmpInst {
+ /// Use Context::createICmpInst(). Don't call the
+ /// constructor directly.
+ ICmpInst(llvm::ICmpInst *CI, Context &Ctx)
+ : CmpInst(CI, Ctx, ClassID::ICmp, Opcode::ICmp) {}
+ friend class Context; // For constructor.
+ using LLVMValType = llvm::ICmpInst;
+
+public:
+ void swapOperands();
+
+ WRAP_BOTH(getSignedPredicate);
+ WRAP_BOTH(getUnsignedPredicate);
+ WRAP_BOTH(isEquality);
+ WRAP_MEMBER(isCommutative);
+ WRAP_MEMBER(isRelational);
+ WRAP_STATIC_PREDICATE(isGT);
+ WRAP_STATIC_PREDICATE(isLT);
+ WRAP_STATIC_PREDICATE(isGE);
+ WRAP_STATIC_PREDICATE(isLE);
+
+ static auto predicates() { return llvm::ICmpInst::predicates(); }
+ static bool compare(const APInt &LHS, const APInt &RHS,
+ ICmpInst::Predicate Pred) {
+ return llvm::ICmpInst::compare(LHS, RHS, Pred);
+ }
+
+ static bool classof(const Instruction *From) {
+ return From->getSubclassID() == ClassID::ICmp;
+ }
+ static bool classof(const Value *From) {
+ return isa<Instruction>(From) && classof(cast<Instruction>(From));
+ }
+};
+
+class FCmpInst : public CmpInst {
+ /// Use Context::createFCmpInst(). Don't call the
+ /// constructor directly.
+ FCmpInst(llvm::FCmpInst *CI, Context &Ctx)
+ : CmpInst(CI, Ctx, ClassID::FCmp, Opcode::FCmp) {}
+ friend class Context; // For constructor.
+ using LLVMValType = llvm::FCmpInst;
+
+public:
+ void swapOperands();
+
+ WRAP_BOTH(isEquality);
+ WRAP_MEMBER(isCommutative);
+ WRAP_MEMBER(isRelational);
+
+ static auto predicates() { return llvm::FCmpInst::predicates(); }
+ static bool compare(const APFloat &LHS, const APFloat &RHS,
+ FCmpInst::Predicate Pred) {
+ return llvm::FCmpInst::compare(LHS, RHS, Pred);
+ }
+
+ static bool classof(const Instruction *From) {
+ return From->getSubclassID() == ClassID::FCmp;
+ }
+ static bool classof(const Value *From) {
+ return From->getSubclassID() == ClassID::FCmp;
+ }
+};
+
+#undef WRAP_STATIC_PREDICATE
+#undef WRAP_MEMBER
+#undef WRAP_BOTH
+
/// An LLLVM Instruction that has no SandboxIR equivalent class gets mapped to
/// an OpaqueInstr.
class OpaqueInst : public SingleLLVMInstructionImpl<llvm::Instruction> {
@@ -3101,6 +3297,12 @@ class Context {
friend PHINode; // For createPHINode()
UnreachableInst *createUnreachableInst(llvm::UnreachableInst *UI);
friend UnreachableInst; // For createUnreachableInst()
+ CmpInst *createCmpInst(llvm::CmpInst *I);
+ friend CmpInst; // For createCmpInst()
+ ICmpInst *createICmpInst(llvm::ICmpInst *I);
+ friend ICmpInst; // For createICmpInst()
+ FCmpInst *createFCmpInst(llvm::FCmpInst *I);
+ friend FCmpInst; // For createFCmpInst()
public:
Context(LLVMContext &LLVMCtx)
diff --git a/llvm/include/llvm/SandboxIR/SandboxIRValues.def b/llvm/include/llvm/SandboxIR/SandboxIRValues.def
index 00c1a6333c8ec4..ac0b942a7cf67e 100644
--- a/llvm/include/llvm/SandboxIR/SandboxIRValues.def
+++ b/llvm/include/llvm/SandboxIR/SandboxIRValues.def
@@ -107,6 +107,9 @@ DEF_INSTR(Cast, OPCODES(\
), CastInst)
DEF_INSTR(PHI, OP(PHI), PHINode)
DEF_INSTR(Unreachable, OP(Unreachable), UnreachableInst)
+DEF_INSTR(Cmp, OP(Cmp), CmpInst)
+DEF_INSTR(ICmp, OP(ICmp), FCmpInst)
+DEF_INSTR(FCmp, OP(FCmp), ICmpInst)
// clang-format on
#ifdef DEF_VALUE
diff --git a/llvm/include/llvm/SandboxIR/Tracker.h b/llvm/include/llvm/SandboxIR/Tracker.h
index c8a9e99a34341d..d3d0bf3dfe7803 100644
--- a/llvm/include/llvm/SandboxIR/Tracker.h
+++ b/llvm/include/llvm/SandboxIR/Tracker.h
@@ -63,6 +63,7 @@ class CatchSwitchInst;
class SwitchInst;
class ConstantInt;
class ShuffleVectorInst;
+class CmpInst;
/// The base class for IR Change classes.
class IRChangeBase {
@@ -130,6 +131,33 @@ class PHIAddIncoming : public IRChangeBase {
#endif
};
+class CmpSetPredicate : public IRChangeBase {
+ CmpInst *Cmp;
+ llvm::CmpInst::Predicate OldP;
+
+public:
+ CmpSetPredicate(CmpInst *Cmp);
+ void revert(Tracker &Tracker) final;
+ void accept() final {}
+#ifndef NDEBUG
+ void dump(raw_ostream &OS) const final { OS << "CmpSetPredicate"; }
+ LLVM_DUMP_METHOD void dump() const final;
+#endif
+};
+
+class CmpSwapOperands : public IRChangeBase {
+ CmpInst *Cmp;
+
+public:
+ CmpSwapOperands(CmpInst *Cmp);
+ void revert(Tracker &Tracker) final;
+ void accept() final {}
+#ifndef NDEBUG
+ void dump(raw_ostream &OS) const final { OS << "CmpSwapOperands"; }
+ LLVM_DUMP_METHOD void dump() const final;
+#endif
+};
+
/// Tracks swapping a Use with another Use.
class UseSwap : public IRChangeBase {
Use ThisUse;
diff --git a/llvm/lib/SandboxIR/SandboxIR.cpp b/llvm/lib/SandboxIR/SandboxIR.cpp
index b75424909f0835..29a92aa82572b8 100644
--- a/llvm/lib/SandboxIR/SandboxIR.cpp
+++ b/llvm/lib/SandboxIR/SandboxIR.cpp
@@ -2462,6 +2462,16 @@ Value *Context::getOrCreateValueInternal(llvm::Value *LLVMV, llvm::User *U) {
It->second = std::unique_ptr<PHINode>(new PHINode(LLVMPhi, *this));
return It->second.get();
}
+ case llvm::Instruction::ICmp: {
+ auto *LLVMICmp = cast<llvm::ICmpInst>(LLVMV);
+ It->second = std::unique_ptr<ICmpInst>(new ICmpInst(LLVMICmp, *this));
+ return It->second.get();
+ }
+ case llvm::Instruction::FCmp: {
+ auto *LLVMFCmp = cast<llvm::FCmpInst>(LLVMV);
+ It->second = std::unique_ptr<FCmpInst>(new FCmpInst(LLVMFCmp, *this));
+ return It->second.get();
+ }
case llvm::Instruction::Unreachable: {
auto *LLVMUnreachable = cast<llvm::UnreachableInst>(LLVMV);
It->second = std::unique_ptr<UnreachableInst>(
@@ -2637,6 +2647,58 @@ PHINode *Context::createPHINode(llvm::PHINode *I) {
auto NewPtr = std::unique_ptr<PHINode>(new PHINode(I, *this));
return cast<PHINode>(registerValue(std::move(NewPtr)));
}
+CmpInst *Context::createCmpInst(llvm::CmpInst *I) {
+ auto NewPtr = std::unique_ptr<CmpInst>(new CmpInst(I, *this));
+ return cast<CmpInst>(registerValue(std::move(NewPtr)));
+}
+ICmpInst *Context::createICmpInst(llvm::ICmpInst *I) {
+ auto NewPtr = std::unique_ptr<ICmpInst>(new ICmpInst(I, *this));
+ return cast<ICmpInst>(registerValue(std::move(NewPtr)));
+}
+FCmpInst *Context::createFCmpInst(llvm::FCmpInst *I) {
+ auto NewPtr = std::unique_ptr<FCmpInst>(new FCmpInst(I, *this));
+ return cast<FCmpInst>(registerValue(std::move(NewPtr)));
+}
+
+void CmpInst::setPredicate(Predicate P) {
+ auto &Tracker = Ctx.getTracker();
+ if (Tracker.isTracking())
+ Tracker.track(std::make_unique<CmpSetPredicate>(this));
+ cast<llvm::CmpInst>(Val)->setPredicate(P);
+}
+
+void CmpInst::swapOperands() {
+ if (ICmpInst *IC = dyn_cast<ICmpInst>(this))
+ IC->swapOperands();
+ else
+ cast<FCmpInst>(this)->swapOperands();
+}
+
+void ICmpInst::swapOperands() {
+ auto &Tracker = Ctx.getTracker();
+ if (Tracker.isTracking())
+ Tracker.track(std::make_unique<CmpSwapOperands>(this));
+ cast<llvm::ICmpInst>(Val)->swapOperands();
+}
+
+void FCmpInst::swapOperands() {
+ auto &Tracker = Ctx.getTracker();
+ if (Tracker.isTracking())
+ Tracker.track(std::make_unique<CmpSwapOperands>(this));
+ cast<llvm::FCmpInst>(Val)->swapOperands();
+}
+
+#ifndef NDEBUG
+void CmpInst::dumpOS(raw_ostream &OS) const {
+ dumpCommonPrefix(OS);
+ dumpCommonSuffix(OS);
+}
+
+void CmpInst::dump() const {
+ dumpOS(dbgs());
+ dbgs() << "\n";
+}
+#endif // NDEBUG
Value *Context::getValue(llvm::Value *V) const {
auto It = LLVMValueToValueMap.find(V);
diff --git a/llvm/lib/SandboxIR/Tracker.cpp b/llvm/lib/SandboxIR/Tracker.cpp
index 953d4bd51353a9..9a824d5211a407 100644
--- a/llvm/lib/SandboxIR/Tracker.cpp
+++ b/llvm/lib/SandboxIR/Tracker.cpp
@@ -248,6 +248,24 @@ void ShuffleVectorSetMask::dump() const {
}
#endif
+CmpSetPredicate::CmpSetPredicate(CmpInst *Cmp)
+ : IRChangeBase(), Cmp(Cmp), OldP(Cmp->getPredicate()) {}
+
+void CmpSetPredicate::revert(Tracker &Tracker) { Cmp->setPredicate(OldP); }
+
+void CmpSetPredicate::dump() const {
+ dump(dbgs());
+ dbgs() << "\n";
+}
+
+CmpSwapOperands::CmpSwapOperands(CmpInst *Cmp) : Cmp(Cmp) {}
+
+void CmpSwapOperands::revert(Tracker &Tracker) { Cmp->swapOperands(); }
+void CmpSwapOperands::dump() const {
+ dump(dbgs());
+ dbgs() << "\n";
+}
+
void Tracker::save() { State = TrackerState::Record; }
void Tracker::revert() {
diff --git a/llvm/unittests/SandboxIR/SandboxIRTest.cpp b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
index bc3fddf9e163dc..5bee722d2b953d 100644
--- a/llvm/unittests/SandboxIR/SandboxIRTest.cpp
+++ b/llvm/unittests/SandboxIR/SandboxIRTest.cpp
@@ -4188,6 +4188,133 @@ define void @foo(i32 %arg) {
EXPECT_EQ(NewPHI->getNumIncomingValues(), PHI->getNumIncomingValues());
}
+void checkSwapOperands(sandboxir::Context &Ctx, llvm::sandboxir::CmpInst *SBCmp,
+ llvm::CmpInst *LLVMCmp) {
+ auto OrigOp0 = SBCmp->getOperand(0);
+ auto OrigOp1 = SBCmp->getOperand(1);
+ EXPECT_EQ(Ctx.getValue(LLVMCmp->getOperand(0)), OrigOp0);
+ EXPECT_EQ(Ctx.getValue(LLVMCmp->getOperand(1)), OrigOp1);
+ // This checks the dispatch mechanism in CmpInst, as well as
+ // the specific implementations.
+ SBCmp->swapOperands();
+ EXPECT_NE(Ctx.getValue(LLVMCmp->getOperand(0)), OrigOp0);
+ EXPECT_NE(Ctx.getValue(LLVMCmp->getOperand(1)), OrigOp1);
+ EXPECT_EQ(Ctx.getValue(LLVMCmp->getOperand(1)), OrigOp0);
+ EXPECT_EQ(Ctx.getValue(LLVMCmp->getOperand(0)), OrigOp1);
+ // Undo it to keep the rest of the test consistent
+ SBCmp->swapOperands();
+}
+
+void checkCommonPredicates(sandboxir::CmpInst *SBCmp, llvm::CmpInst *LLVMCmp) {
+ // Check proper creation
+ auto SBPred = SBCmp->getPredicate();
+ auto LLVMPred = LLVMCmp->getPredicate();
+ EXPECT_EQ(SBPred, LLVMPred);
+ // Check setPredicate
+ SBCmp->setPredicate(llvm::CmpInst::FCMP_FALSE);
+ EXPECT_EQ(LLVMCmp->getPredicate(), llvm::CmpInst::FCMP_FALSE);
+ SBCmp->setPredicate(SBPred);
+ EXPECT_EQ(LLVMCmp->getPredicate(), SBPred);
+ // Ensure the accessors properly forward to the underlying implementation
+ EXPECT_STREQ(sandboxir::CmpInst::getPredicateName(SBPred).data(),
+ llvm::CmpInst::getPredicateName(LLVMPred).data());
+ EXPECT_EQ(SBCmp->isFPPredicate(), LLVMCmp->isFPPredicate());
+ EXPECT_EQ(SBCmp->isIntPredicate(), LLVMCmp->isIntPredicate());
+ EXPECT_EQ(SBCmp->getInversePredicate(), LLVMCmp->getInversePredicate());
+ EXPECT_EQ(SBCmp->getOrderedPredicate(), LLVMCmp->getOrderedPredicate());
+ EXPECT_EQ(SBCmp->getUnorderedPredicate(), LLVMCmp->getUnorderedPredicate());
+ EXPECT_EQ(SBCmp->getSwappedPredicate(), LLVMCmp->getSwappedPredicate());
+ EXPECT_EQ(SBCmp->isStrictPredicate(), LLVMCmp->isStrictPredicate());
+ EXPECT_EQ(SBCmp->isNonStrictPredicate(), LLVMCmp->isNonStrictPredicate());
+ EXPECT_EQ(SBCmp->isRelational(), LLVMCmp->isRelational());
+ if (SBCmp->isRelational()) {
+ EXPECT_EQ(SBCmp->getFlippedStrictnessPredicate(),
+ LLVMCmp->getFlippedStrictnessPredicate());
+ }
+ EXPECT_EQ(SBCmp->isCommutative(), LLVMCmp->isCommutative());
+ EXPECT_EQ(SBCmp->isTrueWhenEqual(), LLVMCmp->isTrueWhenEqual());
+ EXPECT_EQ(SBCmp->isFalseWhenEqual(), LLVMCmp->isFalseWhenEqual());
+ EXPECT_EQ(sandboxir::CmpInst::isOrdered(SBPred),
+ llvm::CmpInst::isOrdered(LLVMPred));
+ EXPECT_EQ(sandboxir::CmpInst::isUnordered(SBPred),
+ llvm::CmpInst::isUnordered(LLVMPred));
+}
+
+TEST_F(SandboxIRTest, ICmpInst) {
+ SCOPED_TRACE("SandboxIRTest sandboxir::ICmpInst tests");
+ parseIR(C, R"IR(
+define void @foo(float %f0, float %f1, i32 %i0, i32 %i1) {
+ bb:
+ %ine = icmp ne i32 %i0, %i1
+ %iugt = icmp ugt i32 %i0, %i1
+ %iuge = icmp uge i32 %i0, %i1
+ %iult = icmp ult i32 %i0, %i1
+ %iule = icmp ule i32 %i0, %i1
+ %isgt = icmp sgt i32 %i0, %i1
+ %isle = icmp sle i32 %i0, %i1
+ %ieg = icmp eq i32 %i0, %i1
+ ret void
+}
+)IR");
+ Function &LLVMF = *M->getFunction("foo");
+ sandboxir::Context Ctx(C);
+ [[maybe_unused]] auto &F = *Ctx.createFunction(&LLVMF);
+
+ auto *LLVMBB = getBasicBlockByName(LLVMF, "bb");
+ auto LLVMIt = LLVMBB->begin();
+ auto *BB = cast<sandboxir::BasicBlock>(Ctx.getValue(LLVMBB));
+ auto It = BB->begin();
+ // Check classof()
+ while (auto *ICmp = dyn_cast<sandboxir::ICmpInst>(&*It++)) {
+ auto *LLVMICmp = cast<llvm::ICmpInst>(&*LLVMIt++);
+ checkSwapOperands(Ctx, ICmp, LLVMICmp);
+ checkCommonPredicates(ICmp, LLVMICmp);
+ EXPECT_EQ(ICmp->isSigned(), LLVMICmp->isSigned());
+ EXPECT_EQ(ICmp->isUnsigned(), LLVMICmp->isUnsigned());
+ EXPECT_EQ(ICmp->getSignedPredicate(), LLVMICmp->getSignedPredicate());
+ EXPECT_EQ(ICmp->getUnsignedPredicate(), LLVMICmp->getUnsignedPredicate());
+ }
+}
+
+TEST_F(SandboxIRTest, FCmpInst) {
+ SCOPED_TRACE("SandboxIRTest sandboxir::FCmpInst tests");
+ parseIR(C, R"IR(
+define void @foo(float %f0, float %f1) {
+bb:
+ %ffalse = fcmp false float %f0, %f1
+ %foeq = fcmp oeq float %f0, %f1
+ %fogt = fcmp ogt float %f0, %f1
+ %folt = fcmp olt float %f0, %f1
+ %fole = fcmp ole float %f0, %f1
+ %fone = fcmp one float %f0, %f1
+ %ford = fcmp ord float %f0, %f1
+ %funo = fcmp uno float %f0, %f1
+ %fueq = fcmp ueq float %f0, %f1
+ %fugt = fcmp ugt float %f0, %f1
+ %fuge = fcmp uge float %f0, %f1
+ %fult = fcmp ult float %f0, %f1
+ %fule = fcmp ule float %f0, %f1
+ %fune = fcmp une float %f0, %f1
+ %ftrue = fcmp true float %f0, %f1
+ ret void
+}
+)IR");
+ Function &LLVMF = *M->getFunction("foo");
+ sandboxir::Context Ctx(C);
+ [[maybe_unused]] auto &F = *Ctx.createFunction(&LLVMF);
+
+ auto *LLVMBB = getBasicBlockByName(LLVMF, "bb");
+ auto LLVMIt = LLVMBB->begin();
+ auto *BB = cast<sandboxir::BasicBlock>(Ctx.getValue(LLVMBB));
+ auto It = BB->begin();
+ // Check classof()
+ while (auto *FCmp = dyn_cast<sandboxir::ICmpInst>(&*It++)) {
+ auto *LLVMFCmp = cast<llvm::ICmpInst>(&*LLVMIt++);
+ checkSwapOperands(Ctx, FCmp, LLVMFCmp);
+ checkCommonPredicates(FCmp, LLVMFCmp);
+ }
+}
+
TEST_F(SandboxIRTest, UnreachableInst) {
parseIR(C, R"IR(
define void @foo() {
diff --git a/llvm/unittests/SandboxIR/TrackerTest.cpp b/llvm/unittests/SandboxIR/TrackerTest.cpp
index ca6effb727bf37..b4905c2231e3c8 100644
--- a/llvm/unittests/SandboxIR/TrackerTest.cpp
+++ b/llvm/unittests/SandboxIR/TrackerTest.cpp
@@ -1439,6 +1439,49 @@ define void @foo(i8 %arg0, i8 %arg1, i8 %arg2) {
EXPECT_EQ(PHI->getIncomingValue(1), Arg1);
}
+void checkCmpInst(sandboxir::Context &Ctx, sandboxir::CmpInst *Cmp) {
+ Ctx.save();
+ auto OrigP = Cmp->getPredicate();
+ auto NewP = Cmp->getSwappedPredicate();
+ Cmp->setPredicate(NewP);
+ EXPECT_EQ(Cmp->getPredicate(), NewP);
+ Ctx.revert();
+ EXPECT_EQ(Cmp->getPredicate(), OrigP);
+
+ Ctx.save();
+ auto OrigOp0 = Cmp->getOperand(0);
+ auto OrigOp1 = Cmp->getOperand(1);
+ Cmp->swapOperands();
+ EXPECT_EQ(Cmp->getPredicate(), NewP);
+ EXPECT_EQ(Cmp->getOperand(0), OrigOp1);
+ EXPECT_EQ(Cmp->getOperand(1), OrigOp0);
+ Ctx.revert();
+ EXPECT_EQ(Cmp->getPredicate(), OrigP);
+ EXPECT_EQ(Cmp->getOperand(0), OrigOp0);
+ EXPECT_EQ(Cmp->getOperand(1), OrigOp1);
+}
+
+TEST_F(TrackerTest, CmpInst) {
+ SCOPED_TRACE("TrackerTest sandboxir::CmpInst tests");
+ parseIR(C, R"IR(
+define void @foo(i64 %i0, i64 %i1, float %f0, float %f1) {
+ %foeq = fcmp ogt float %f0, %f1
+ %ioeq = icmp uge i64 %i0, %i1
+
+ ret void
+}
+)IR");
+ Function &LLVMF = *M->getFunction("foo");
+ sandboxir::Context Ctx(C);
+ auto &F = *Ctx.createFunction(&LLVMF);
+ auto *BB = &*F.begin();
+ auto It = BB->begin();
+ auto *FCmp = cast<sandboxir::FCmpInst>(&*It++);
+ checkCmpInst(Ctx, FCmp);
+ auto *ICmp = cast<sandboxir::ICmpInst>(&*It++);
+ checkCmpInst(Ctx, ICmp);
+}
+
TEST_F(TrackerTest, SetVolatile) {
parseIR(C, R"IR(
define void @foo(ptr %arg0, i8 %val) {
More information about the llvm-commits
mailing list