[Support] Simplify KnownBits::icmp helpers. NFC.

[foad]

Summary

Remove some special cases that aren't really any simpler than the
general case.

[RKSimon]

llvm/lib/Support/KnownBits.cpp

273–274

Is this still worth keeping?

[foad]

llvm/lib/Support/KnownBits.cpp

273–274

Yes, it's the only way we can ever return true.

[RKSimon]

llvm/lib/Support/KnownBits.cpp

273–274

eek - sorry about that!

[RKSimon]

LGTM

llvm/lib/Support/KnownBits.cpp

KnownBits KnownBits::ashr(const KnownBits &LHS, const KnownBits &RHS) {
 
   Known.Zero.setHighBits(MinLeadingZeros);
   Known.One.setHighBits(MinLeadingOnes);
   return Known;
 }
 
 Optional<bool> KnownBits::eq(const KnownBits &LHS, const KnownBits &RHS) {
   if (LHS.isConstant() && RHS.isConstant())
     return Optional<bool>(LHS.getConstant() == RHS.getConstant());
-  if (LHS.getMaxValue().ult(RHS.getMinValue()) ||
-      LHS.getMinValue().ugt(RHS.getMaxValue()))
-    return Optional<bool>(false);
   if (LHS.One.intersects(RHS.Zero) || RHS.One.intersects(LHS.Zero))
     return Optional<bool>(false);
   return None;
 }
 
 Optional<bool> KnownBits::ne(const KnownBits &LHS, const KnownBits &RHS) {
   if (Optional<bool> KnownEQ = eq(LHS, RHS))
     return Optional<bool>(!KnownEQ.getValue());
   return None;
 }
 
 Optional<bool> KnownBits::ugt(const KnownBits &LHS, const KnownBits &RHS) {
-  if (LHS.isConstant() && RHS.isConstant())
-    return Optional<bool>(LHS.getConstant().ugt(RHS.getConstant()));
   // LHS >u RHS -> false if umax(LHS) <= umax(RHS)
   if (LHS.getMaxValue().ule(RHS.getMinValue()))
     return Optional<bool>(false);
   // LHS >u RHS -> true if umin(LHS) > umax(RHS)
   if (LHS.getMinValue().ugt(RHS.getMaxValue()))
     return Optional<bool>(true);
   return None;
 }
 
 Optional<bool> KnownBits::uge(const KnownBits &LHS, const KnownBits &RHS) {
   if (Optional<bool> IsUGT = ugt(RHS, LHS))
     return Optional<bool>(!IsUGT.getValue());
   return None;
 }
 
 Optional<bool> KnownBits::ult(const KnownBits &LHS, const KnownBits &RHS) {
   return ugt(RHS, LHS);
 }
 
 Optional<bool> KnownBits::ule(const KnownBits &LHS, const KnownBits &RHS) {
   return uge(RHS, LHS);
 }
 
 Optional<bool> KnownBits::sgt(const KnownBits &LHS, const KnownBits &RHS) {
-  if (LHS.isConstant() && RHS.isConstant())
-    return Optional<bool>(LHS.getConstant().sgt(RHS.getConstant()));
   // LHS >s RHS -> false if smax(LHS) <= smax(RHS)
   if (LHS.getSignedMaxValue().sle(RHS.getSignedMinValue()))
     return Optional<bool>(false);
   // LHS >s RHS -> true if smin(LHS) > smax(RHS)
   if (LHS.getSignedMinValue().sgt(RHS.getSignedMaxValue()))
     return Optional<bool>(true);
   return None;
 }