RPCS3/llvm-mirror
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm-mirror.git synced 2024-12-25 21:16:19 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Sink isTrueWhenEqual from ICmpInst to CmpInst. Add a matching isFalseWhenEqual

Browse Source 
which is equal to !isTrueWhenEqual for ints but not for floats.

llvm-svn: 85036
This commit is contained in:
Nick Lewycky 2009-10-25 03:50:03 +00:00
parent 499815e9f9
commit a16e115bd4
3 changed files with 36 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
include/llvm/InstrTypes.h
View File

@ -718,6 +718,18 @@ public:
/// @brief Determine if this is an equals/not equals predicate.
bool isEquality();
/// This is just a convenience.
/// @brief Determine if this is true when both operands are the same.
bool isTrueWhenEqual() const {
return isTrueWhenEqual(getPredicate());
}
/// This is just a convenience.
/// @brief Determine if this is false when both operands are the same.
bool isFalseWhenEqual() const {
return isFalseWhenEqual(getPredicate());
}
/// @returns true if the predicate is unsigned, false otherwise.
/// @brief Determine if the predicate is an unsigned operation.
static bool isUnsigned(unsigned short predicate);
@ -732,6 +744,12 @@ public:
/// @brief Determine if the predicate is an unordered operation.
static bool isUnordered(unsigned short predicate);
/// Determine if the predicate is true when comparing a value with itself.
static bool isTrueWhenEqual(unsigned short predicate);
/// Determine if the predicate is false when comparing a value with itself.
static bool isFalseWhenEqual(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) {

16
include/llvm/Instructions.h
View File

@ -701,22 +701,6 @@ public:
/// @brief Determine if the predicate is signed.
static bool isSignedPredicate(Predicate pred);
/// @returns true if the specified compare predicate is
/// true when both operands are equal...
/// @brief Determine if the icmp is true when both operands are equal
static bool isTrueWhenEqual(ICmpInst::Predicate pred) {
return pred == ICmpInst::ICMP_EQ || pred == ICmpInst::ICMP_UGE ||
pred == ICmpInst::ICMP_SGE || pred == ICmpInst::ICMP_ULE ||
pred == ICmpInst::ICMP_SLE;
}
/// @returns true if the specified compare instruction is
/// true when both operands are equal...
/// @brief Determine if the ICmpInst returns true when both operands are equal
bool isTrueWhenEqual() {
return isTrueWhenEqual(getPredicate());
}
/// Initialize a set of values that all satisfy the predicate with C.
/// @brief Make a ConstantRange for a relation with a constant value.
static ConstantRange makeConstantRange(Predicate pred, const APInt &C);

19
lib/VMCore/Instructions.cpp
View File

@ -2943,7 +2943,7 @@ bool CmpInst::isUnsigned(unsigned short predicate) {
}
}
bool CmpInst::isSigned(unsigned short predicate){
bool CmpInst::isSigned(unsigned short predicate) {
switch (predicate) {
default: return false;
case ICmpInst::ICMP_SLT: case ICmpInst::ICMP_SLE: case ICmpInst::ICMP_SGT:
@ -2969,6 +2969,23 @@ bool CmpInst::isUnordered(unsigned short predicate) {
}
}
bool CmpInst::isTrueWhenEqual(unsigned short predicate) {
switch(predicate) {
default: return false;
case ICMP_EQ: case ICMP_UGE: case ICMP_ULE: case ICMP_SGE: case ICMP_SLE:
case FCMP_TRUE: case FCMP_UEQ: case FCMP_UGE: case FCMP_ULE: return true;
}
}
bool CmpInst::isFalseWhenEqual(unsigned short predicate) {
switch(predicate) {
case ICMP_NE: case ICMP_UGT: case ICMP_ULT: case ICMP_SGT: case ICMP_SLT:
case FCMP_FALSE: case FCMP_ONE: case FCMP_OGT: case FCMP_OLT: return true;
default: return false;
}
}
//===----------------------------------------------------------------------===//
// SwitchInst Implementation
//===----------------------------------------------------------------------===//