+//===----------------------------------------------------------------------===//
+// CmpInst Class
+//===----------------------------------------------------------------------===//
+
+/// This class is the base class for the comparison instructions.
+/// @brief Abstract base class of comparison instructions.
+// FIXME: why not derive from BinaryOperator?
+class CmpInst: public Instruction {
+ void *operator new(size_t, unsigned); // DO NOT IMPLEMENT
+ CmpInst(); // do not implement
+protected:
+ CmpInst(const Type *ty, Instruction::OtherOps op, unsigned short pred,
+ Value *LHS, Value *RHS, const std::string &Name = "",
+ Instruction *InsertBefore = 0);
+
+ CmpInst(const Type *ty, Instruction::OtherOps op, unsigned short pred,
+ Value *LHS, Value *RHS, const std::string &Name,
+ BasicBlock *InsertAtEnd);
+
+public:
+ /// This enumeration lists the possible predicates for CmpInst subclasses.
+ /// Values in the range 0-31 are reserved for FCmpInst, while values in the
+ /// range 32-64 are reserved for ICmpInst. This is necessary to ensure the
+ /// predicate values are not overlapping between the classes.
+ enum Predicate {
+ // Opcode U L G E Intuitive operation
+ FCMP_FALSE = 0, /// 0 0 0 0 Always false (always folded)
+ FCMP_OEQ = 1, /// 0 0 0 1 True if ordered and equal
+ FCMP_OGT = 2, /// 0 0 1 0 True if ordered and greater than
+ FCMP_OGE = 3, /// 0 0 1 1 True if ordered and greater than or equal
+ FCMP_OLT = 4, /// 0 1 0 0 True if ordered and less than
+ FCMP_OLE = 5, /// 0 1 0 1 True if ordered and less than or equal
+ FCMP_ONE = 6, /// 0 1 1 0 True if ordered and operands are unequal
+ FCMP_ORD = 7, /// 0 1 1 1 True if ordered (no nans)
+ FCMP_UNO = 8, /// 1 0 0 0 True if unordered: isnan(X) | isnan(Y)
+ FCMP_UEQ = 9, /// 1 0 0 1 True if unordered or equal
+ FCMP_UGT = 10, /// 1 0 1 0 True if unordered or greater than
+ FCMP_UGE = 11, /// 1 0 1 1 True if unordered, greater than, or equal
+ FCMP_ULT = 12, /// 1 1 0 0 True if unordered or less than
+ FCMP_ULE = 13, /// 1 1 0 1 True if unordered, less than, or equal
+ FCMP_UNE = 14, /// 1 1 1 0 True if unordered or not equal
+ FCMP_TRUE = 15, /// 1 1 1 1 Always true (always folded)
+ FIRST_FCMP_PREDICATE = FCMP_FALSE,
+ LAST_FCMP_PREDICATE = FCMP_TRUE,
+ BAD_FCMP_PREDICATE = FCMP_TRUE + 1,
+ ICMP_EQ = 32, /// equal
+ ICMP_NE = 33, /// not equal
+ ICMP_UGT = 34, /// unsigned greater than
+ ICMP_UGE = 35, /// unsigned greater or equal
+ ICMP_ULT = 36, /// unsigned less than
+ ICMP_ULE = 37, /// unsigned less or equal
+ ICMP_SGT = 38, /// signed greater than
+ ICMP_SGE = 39, /// signed greater or equal
+ ICMP_SLT = 40, /// signed less than
+ ICMP_SLE = 41, /// signed less or equal
+ FIRST_ICMP_PREDICATE = ICMP_EQ,
+ LAST_ICMP_PREDICATE = ICMP_SLE,
+ BAD_ICMP_PREDICATE = ICMP_SLE + 1
+ };
+
+ // allocate space for exactly two operands
+ void *operator new(size_t s) {
+ return User::operator new(s, 2);
+ }
+ /// Construct a compare instruction, given the opcode, the predicate and
+ /// the two operands. Optionally (if InstBefore is specified) insert the
+ /// instruction into a BasicBlock right before the specified instruction.
+ /// The specified Instruction is allowed to be a dereferenced end iterator.
+ /// @brief Create a CmpInst
+ static CmpInst *Create(OtherOps Op, unsigned short predicate, Value *S1,
+ Value *S2, const std::string &Name = "",
+ Instruction *InsertBefore = 0);
+
+ /// Construct a compare instruction, given the opcode, the predicate and the
+ /// two operands. Also automatically insert this instruction to the end of
+ /// the BasicBlock specified.
+ /// @brief Create a CmpInst
+ static CmpInst *Create(OtherOps Op, unsigned short predicate, Value *S1,
+ Value *S2, const std::string &Name,
+ BasicBlock *InsertAtEnd);
+
+ /// @brief Get the opcode casted to the right type
+ OtherOps getOpcode() const {
+ return static_cast<OtherOps>(Instruction::getOpcode());
+ }
+
+ /// @brief Return the predicate for this instruction.
+ Predicate getPredicate() const { return Predicate(SubclassData); }
+
+ /// @brief Set the predicate for this instruction to the specified value.
+ void setPredicate(Predicate P) { SubclassData = P; }
+
+ /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
+ /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
+ /// @returns the inverse predicate for the instruction's current predicate.
+ /// @brief Return the inverse of the instruction's predicate.
+ Predicate getInversePredicate() const {
+ return getInversePredicate(getPredicate());
+ }
+
+ /// For example, EQ -> NE, UGT -> ULE, SLT -> SGE,
+ /// OEQ -> UNE, UGT -> OLE, OLT -> UGE, etc.
+ /// @returns the inverse predicate for predicate provided in \p pred.
+ /// @brief Return the inverse of a given predicate
+ static Predicate getInversePredicate(Predicate pred);
+
+ /// For example, EQ->EQ, SLE->SGE, ULT->UGT,
+ /// OEQ->OEQ, ULE->UGE, OLT->OGT, etc.
+ /// @returns the predicate that would be the result of exchanging the two
+ /// operands of the CmpInst instruction without changing the result
+ /// produced.
+ /// @brief Return the predicate as if the operands were swapped
+ Predicate getSwappedPredicate() const {
+ return getSwappedPredicate(getPredicate());
+ }
+
+ /// This is a static version that you can use without an instruction
+ /// available.
+ /// @brief Return the predicate as if the operands were swapped.
+ static Predicate getSwappedPredicate(Predicate pred);
+
+ /// @brief Provide more efficient getOperand methods.
+ DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
+
+ /// This is just a convenience that dispatches to the subclasses.
+ /// @brief Swap the operands and adjust predicate accordingly to retain
+ /// the same comparison.
+ void swapOperands();
+
+ /// This is just a convenience that dispatches to the subclasses.
+ /// @brief Determine if this CmpInst is commutative.
+ bool isCommutative();
+
+ /// This is just a convenience that dispatches to the subclasses.
+ /// @brief Determine if this is an equals/not equals predicate.
+ bool isEquality();
+
+ /// @returns true if the predicate is unsigned, false otherwise.
+ /// @brief Determine if the predicate is an unsigned operation.
+ static bool isUnsigned(unsigned short predicate);
+
+ /// @returns true if the predicate is signed, false otherwise.
+ /// @brief Determine if the predicate is an signed operation.
+ static bool isSigned(unsigned short predicate);
+
+ /// @brief Determine if the predicate is an ordered operation.
+ static bool isOrdered(unsigned short predicate);
+
+ /// @brief Determine if the predicate is an unordered operation.
+ static bool isUnordered(unsigned short predicate);
+
+ /// @brief Methods for support type inquiry through isa, cast, and dyn_cast:
+ static inline bool classof(const CmpInst *) { return true; }
+ static inline bool classof(const Instruction *I) {
+ return I->getOpcode() == Instruction::ICmp ||
+ I->getOpcode() == Instruction::FCmp ||
+ I->getOpcode() == Instruction::VICmp ||
+ I->getOpcode() == Instruction::VFCmp;
+ }
+ static inline bool classof(const Value *V) {
+ return isa<Instruction>(V) && classof(cast<Instruction>(V));
+ }
+ /// Backward-compatible interfaces
+ /// @deprecated in 2.4, do not use, will disappear soon
+ static CmpInst *create(OtherOps Op, unsigned short predicate, Value *S1,
+ Value *S2, const std::string &Name = "",
+ Instruction *InsertBefore = 0) {
+ return Create(Op, predicate, S1, S2, Name, InsertBefore);
+ }
+ static CmpInst *create(OtherOps Op, unsigned short predicate, Value *S1,
+ Value *S2, const std::string &Name,
+ BasicBlock *InsertAtEnd) {
+ return Create(Op, predicate, S1, S2, Name, InsertAtEnd);
+ }