[Sema] Implement -Wmaybe-tautological-constant-compare for when the tautologicalness is data model dependent

[lebedev.ri]

Summary

As brought up in D39149, and post-review mails for some other commits,
the current -Wtautological-constant-compare is dumb, much like
unreachable code diagnostic.

The common complaint is that it diagnoses the comparisons between an int and
long when compiling for a 32-bit target as tautological, but not when
compiling for 64-bit targets. The underlying problem is obvious: data model.
In most cases, 64-bit target is LP64 (int is 32-bit, long and pointer are
64-bit), and the 32-bit target is ILP32 (int, long, and pointer are 32-bit).

I.e. the common pattern is: (pseudocode)

#include <limits>
#include <cstdint>
int main() {
  using T1 = long;
  using T2 = int;

  T1 r;
  if (r < std::numeric_limits<T2>::min()) {}
  if (r > std::numeric_limits<T2>::max()) {}
}

The fix is simple: if the types of the values being compared are different, but
are of the same size, then we issue -Wmaybe-tautological-constant-compare
instead of -Wtautological-constant-compare.
That new diagnostic is *not* enabled by default/-Wall/-Wextra.

[lebedev.ri]

I'm sure i have missed some corner case :)

In D39149#911024, @rsmith wrote:

In D39149#910936, @smeenai wrote:

...

That would also suppress warnings for cases like 'ch > CHAR_MAX', when ch is a char, but we could detect and re-enable the warning for such cases by, say, always warning if the constant side is an integer literal.

In D39149#911052, @smeenai wrote:

In D39149#911024, @rsmith wrote:

This sounds like a very promising direction. (That is: if the types of the values being compared are different, but are of the same size, then suppress the warning or move it to a different warning group that's not part of -Wtautological-compare.) That would also suppress warnings for cases like 'ch > CHAR_MAX', when ch is a char, but we could detect and re-enable the warning for such cases by, say, always warning if the constant side is an integer literal.

When you say "always warning if the constant side is an integer literal", do you mean if it's a straight-up integer literal, or if it's an expression which evaluates to an integer literal at compile time? For example, would there be a difference if you were comparing to numeric_limits<int>::max() vs. INT_MAX?

Please do note that if the integer literal / integral constant expression is originating from *any* macro, this entire tautologicalness diagnostic is silenced.
I very much don't like this, because it would warn on if(char > 255) but would not warn on assert(char <= 255);.

[rjmccall]

The actual choice of integer type is not stable across targets any more than the size is. In practice, people often don't use int and long, they use standard typedefs like size_t and uint64_t, but the actual type chosen for size_t is arbitrary when there are multiple types at that bit-width. So I'm concerned that you're suppressing more than you think here and still not going to satisfy people.

Also, "data model" is not a term in use. Use "target" or "target platform".

[lebedev.ri]

In D39462#912011, @rjmccall wrote:

The actual choice of integer type is not stable across targets any more than the size is. In practice, people often don't use int and long, they use standard typedefs like size_t and uint64_t, but the actual type chosen for size_t is arbitrary when there are multiple types at that bit-width.

The internal canonical types are compared, so all this typedef sugar will be silently ignored.

So I'm concerned that you're suppressing more than you think here and still not going to satisfy people.

Possibly...
But it will at least make it easier to deal with the most common pattern "that obviously should not warn".
I'd love to hear better ideas

In D39462#912011, @rjmccall wrote:

Also, "data model" is not a term in use. Use "target" or "target platform".

Changed to for the current target platform, ...

[smeenai]

This solves the issue in D39149, at least.

[efriedma]

The internal canonical types are compared, so all this typedef sugar will be silently ignored.

Yes, and that's precisely the problem. On many 32-bit platforms, both "size_t" and "uint32_t" are typedefs for "unsigned int"; on some 32-bit platforms, "size_t" is an "unsigned long". So whether this patch suppresses the warning for a comparison between size_t and uint32_t depends on the target ABI.

[lebedev.ri]

In D39462#912011, @rjmccall wrote:

The actual choice of integer type is not stable across targets any more than the size is. In practice, people often don't use int and long, they use standard typedefs like size_t and uint64_t, but the actual type chosen for size_t is arbitrary when there are multiple types at that bit-width.

In D39462#912387, @efriedma wrote:

The internal canonical types are compared, so all this typedef sugar will be silently ignored.

Yes, and that's precisely the problem. On many 32-bit platforms, both "size_t" and "uint32_t" are typedefs for "unsigned int"; on some 32-bit platforms, "size_t" is an "unsigned long". So whether this patch suppresses the warning for a comparison between size_t and uint32_t depends on the target ABI.

Okay, changed the code to compare not the internal canonical types, but just the types.
Added tests that show that it does detect&complain about comparing two different types, that point to the same type.

Also. should it really not be in -Wextra?

[rjmccall]

So, that change makes this very interesting, because I think the right way of looking at it is as the first in a larger family of warnings that attempt to treat typedefs as if they were a much stronger type-system feature, i.e. that warn about all sorts of conversions between different typedef types. That should be good enough to serve as a basic rule for a stronger portability warning, as well as generally pointing out all sorts of potential logical errors like passing a bit_offset_t off as a byte_offset_t.

Such a warning really needs more exceptions than a simple exact-type-spelling rule would give you. There are several language features that add type sugar which should really be ignored for the purposes of the warning, such as typeof and decltype; and conversely, there are several features that remove (or just never add) type sugar that also shouldn't cause problems, like literals or C++ templates.

I think that feature could be really useful as a major new diagnostic, but I do want to warn you that it's probably a pretty large project, somewhat on the scale of implementing -Wconversion in the first place. Also, yeah, my first thought is that it's probably outside of a reasonable rubric for even -Wextra, especially while it's being actively developed.

[lebedev.ri]

In D39462#917421, @rjmccall wrote:

So, that change makes this very interesting, because I think the right way of looking at it is as the first in a larger family of warnings that attempt to treat typedefs as if they were a much stronger type-system feature, i.e. that warn about all sorts of conversions between different typedef types. That should be good enough to serve as a basic rule for a stronger portability warning, as well as generally pointing out all sorts of potential logical errors like passing a bit_offset_t off as a byte_offset_t.

Such a warning really needs more exceptions than a simple exact-type-spelling rule would give you. There are several language features that add type sugar which should really be ignored for the purposes of the warning, such as typeof and decltype; and conversely, there are several features that remove (or just never add) type sugar that also shouldn't cause problems, like literals or C++ templates.

I think that feature could be really useful as a major new diagnostic

That is all very cool and shiny, but could we please go back to the real world, please? :)

In D39462#917421, @rjmccall wrote:

but I do want to warn you that it's probably a pretty large project, somewhat on the scale of implementing -Wconversion in the first place.

Exactly. My expirience shows that unless i'm actually interested, i will either fail, or it will work poorly.
And i can tell you that i'm not quite interested in implementing what you seem to suggest to implement.

What i would like to do, is to finish *this* differential, that would make D38101 less noisy for some questionable edge-cases,
without

In D39462#917421, @rjmccall wrote:

a pretty large project, somewhat on the scale of implementing -Wconversion in the first place.

Can that happen? :)

In D39462#917421, @rjmccall wrote:

Also, yeah, my first thought is that it's probably outside of a reasonable rubric for even -Wextra, especially while it's being actively developed.

For that other diagnostic you suggest - sure.

---

I think the general direction is correct, but there are unhandled cases yet, e.g , so I'm somewhat lost here, and would love to hear some actual feedback for the suggested code.

[rjmccall]

I don't speak for the entire project, but I'm not sure I'm interested in the diagnostic you're actually offering to contribute here. It may produce a warning on your specific test case, but I think it's really much too rigid and will lead to massive false positives. I sketched the basics of a design that I think I could accept; if you don't want to implement it, that's your right, but that doesn't make me more likely to accept what you're willing to implement.

[lebedev.ri]

In D39462#922826, @rjmccall wrote:

I don't speak for the entire project, but I'm not sure I'm interested in the diagnostic you're actually offering to contribute here. It may produce a warning on your specific test case, but I think it's really much too rigid and will lead to massive false positives. I sketched the basics of a design that I think I could accept; if you don't want to implement it, that's your right, but that doesn't make me more likely to accept what you're willing to implement.

Just to reiterate that we are talking about the same thing here:

• D38101 is already merged. -Wtautological-constant-compare is here.
• There are cases when it warns for some target platform, but not the other, as complained in D39149, and post-review mails for D38101
• So far it seems all the cases reduce to

#include <limits>
#include <cstdint>
int main() {
  using T1 = long;
  using T2 = int;

  T1 r;
  if (r < std::numeric_limits<T2>::min()) {}
  if (r > std::numeric_limits<T2>::max()) {}
}

• *This* differential (D39462) would find such cases, and issue them under different diagnostic, thus reducing the "false-positive" (it is an open question whether they are actual false-positives or not) rate of -Wtautological-constant-compare.

Are you suggesting me to drop this, and implement some other huge new diagnostic that may catch such cases before -Wtautological-constant-compare, thus preventing -Wtautological-constant-compare from triggering on that completely?

[rjmccall]

In D39462#922844, @lebedev.ri wrote:

In D39462#922826, @rjmccall wrote:

I don't speak for the entire project, but I'm not sure I'm interested in the diagnostic you're actually offering to contribute here. It may produce a warning on your specific test case, but I think it's really much too rigid and will lead to massive false positives. I sketched the basics of a design that I think I could accept; if you don't want to implement it, that's your right, but that doesn't make me more likely to accept what you're willing to implement.

Just to reiterate that we are talking about the same thing here:

• D38101 is already merged. -Wtautological-constant-compare is here.
• There are cases when it warns for some target platform, but not the other, as complained in D39149, and post-review mails for D38101
• So far it seems all the cases reduce to

#include <limits>
#include <cstdint>
int main() {
  using T1 = long;
  using T2 = int;

  T1 r;
  if (r < std::numeric_limits<T2>::min()) {}
  if (r > std::numeric_limits<T2>::max()) {}
}

• *This* differential (D39462) would find such cases, and issue them under different diagnostic, thus reducing the "false-positive" (it is an open question whether they are actual false-positives or not) rate of -Wtautological-constant-compare.

I think you might have this backwards. We think of the check for the diagnostic as being the test, so a false positive is when we warn when we shouldn't. What you've identified here is a false *negative*, i.e. a case where you believe it should warn (because it would warn on a different target) that it currently does not.

Are you suggesting me to drop this, and implement some other huge new diagnostic that may catch such cases before -Wtautological-constant-compare, thus preventing -Wtautological-constant-compare from triggering on that completely?

"This warning triggers on some targets and not on others" is a far more widespread problem than just -Wtautological-constant-compare. I don't think your patch reasonably solves that problem, even for just this diagnostic. I think a "strong typedef" analysis would address it, but that's going to require a significant amount of work, even if you literally only apply it to this warning, because you're going to have to implement a bunch of more careful logic about inferring when to propagate typedefs through e.g. templates, as well as when to consider a template to have "propagated" through arithmetic promotion in the same way we propagate integer ranges.

[smeenai]

In D39462#922847, @rjmccall wrote:

In D39462#922844, @lebedev.ri wrote:

In D39462#922826, @rjmccall wrote:

I don't speak for the entire project, but I'm not sure I'm interested in the diagnostic you're actually offering to contribute here. It may produce a warning on your specific test case, but I think it's really much too rigid and will lead to massive false positives. I sketched the basics of a design that I think I could accept; if you don't want to implement it, that's your right, but that doesn't make me more likely to accept what you're willing to implement.

Just to reiterate that we are talking about the same thing here:

• D38101 is already merged. -Wtautological-constant-compare is here.
• There are cases when it warns for some target platform, but not the other, as complained in D39149, and post-review mails for D38101
• So far it seems all the cases reduce to

#include <limits>
#include <cstdint>
int main() {
  using T1 = long;
  using T2 = int;

  T1 r;
  if (r < std::numeric_limits<T2>::min()) {}
  if (r > std::numeric_limits<T2>::max()) {}
}

• *This* differential (D39462) would find such cases, and issue them under different diagnostic, thus reducing the "false-positive" (it is an open question whether they are actual false-positives or not) rate of -Wtautological-constant-compare.

I think you might have this backwards. We think of the check for the diagnostic as being the test, so a false positive is when we warn when we shouldn't. What you've identified here is a false *negative*, i.e. a case where you believe it should warn (because it would warn on a different target) that it currently does not.

I guess you can think of it both ways, but the concern for D39149 was definitely that of a false positive. More precisely, a long variable was being compared against the limits for int. On a 64-bit platform, you would have no warning. On a 32-bit platform, you would have a warning, by virtue of int and long being the same size. I consider the warning on the 32-bit platform to be a false positive, since the comparison is serving a purpose, but the compiler is still flagging it as tautological. In general, I would want -Wtautological-constant-compare to only fire in cases where the comparison is guaranteed to be tautological, and would consider anything else to be a false positive.

[rjmccall]

I see. The problem now, though, is that things involving, say, a size_t and a numeric_limits<size_t> will never warn.

[lebedev.ri]

In D39462#922847, @rjmccall wrote:

In D39462#922844, @lebedev.ri wrote:

In D39462#922826, @rjmccall wrote:

I don't speak for the entire project, but I'm not sure I'm interested in the diagnostic you're actually offering to contribute here. It may produce a warning on your specific test case, but I think it's really much too rigid and will lead to massive false positives. I sketched the basics of a design that I think I could accept; if you don't want to implement it, that's your right, but that doesn't make me more likely to accept what you're willing to implement.

Just to reiterate that we are talking about the same thing here:

• D38101 is already merged. -Wtautological-constant-compare is here.
• There are cases when it warns for some target platform, but not the other, as complained in D39149, and post-review mails for D38101
• So far it seems all the cases reduce to

#include <limits>
#include <cstdint>
int main() {
  using T1 = long;
  using T2 = int;

  T1 r;
  if (r < std::numeric_limits<T2>::min()) {}
  if (r > std::numeric_limits<T2>::max()) {}
}

• *This* differential (D39462) would find such cases, and issue them under different diagnostic, thus reducing the "false-positive" (it is an open question whether they are actual false-positives or not) rate of -Wtautological-constant-compare.

I think you might have this backwards.

The views here are clearly polarized.

We think of the check for the diagnostic as being the test, so a false positive is when we warn when we shouldn't.

Yes.

What you've identified here is a false *negative*, i.e. a case where you believe it should warn (because it would warn on a different target) that it currently does not.

I'm sorry, but where are you getting this from? I don't believe these warnings should be elevated to always warn even if it is not tautological for the current target platform. I don't think i have said that?

Are you suggesting me to drop this, and implement some other huge new diagnostic that may catch such cases before -Wtautological-constant-compare, thus preventing -Wtautological-constant-compare from triggering on that completely?

"This warning triggers on some targets and not on others" is a far more widespread problem than just -Wtautological-constant-compare. I don't think your patch reasonably solves that problem, even for just this diagnostic. I think a "strong typedef" analysis would address it, but that's going to require a significant amount of work, even if you literally only apply it to this warning, because you're going to have to implement a bunch of more careful logic about inferring when to propagate typedefs through e.g. templates, as well as when to consider a template to have "propagated" through arithmetic promotion in the same way we propagate integer ranges.

First and foremost, i do admit that i don't have the full picture in mind.
If other reviewers agree with Your view, i will abandon this differential. Hopefully someone with clearer understanding will come up with a better solution.

In D39462#922887, @rjmccall wrote:

I see. The problem now, though, is that things involving, say, a size_t and a numeric_limits<size_t> will never warn.

The same type (size_t) will be on the both sides, so i think it should still warn. (I do see that the test disagrees with me.)

[rjmccall]

That's the template type-propagation problem: the template was invoked with a size_t, but that's erased down to the canonical type by the template machinery. That can't be fixed within the template, but at use sites, we could theoretically recognize that e.g. the result of the callee was originally spelled T and then look for how T was determined; here it comes from an explicit template argument, whose spelling can just be propagated into the sugared type of the call expression. But that's the sort of analysis I think you'd need to do a good job with in order to make this adjustment successful.

[bcain]

I'd like to understand/resurrect this change, so I'll try to summarize. Please correct this as appropriate:

1. We got here because libc++ has code that triggers a warning for some targets (those whose int and long have the same size).
2. This change would "move" the existing logic for -Wtautological-constant-compare to -Wmaybe-tautological-constant-compare and replace -Wtautological-constant-compare logic with one less likely to report that the code in libc++ is wrong.
3. A superior checker could be defined that would thread the needle between these cases: warning only when it should and not when it shouldn't. This would be preferred because it avoids the creation of similar but slightly distinct warnings.

If this summary is really the case, what's the best way to break this stalemate? Could we implement this change for now and improve the warnings later? If the answer is 'no', then let's please restore D39149.

AFAICT Marshall and John have strong feelings on each of these proposed libc++ and clang changes -- it would be valuable if each of you could weigh in.

[lebedev.ri]

In D39462#936566, @bcain wrote:

I'd like to understand/resurrect this change, so I'll try to summarize. Please correct this as appropriate:

1. We got here because libc++ has code that triggers a warning for some targets (those whose int and long have the same size).
2. This change would "move" the existing logic for -Wtautological-constant-compare to -Wmaybe-tautological-constant-compare and replace -Wtautological-constant-compare logic with one less likely to report that the code in libc++ is wrong.
3. A superior checker could be defined that would thread the needle between these cases: warning only when it should and not when it shouldn't. This would be preferred because it avoids the creation of similar but slightly distinct warnings.

If this summary is really the case, what's the best way to break this stalemate? Could we implement this change for now and improve the warnings later? If the answer is 'no', then let's please restore D39149.

AFAICT Marshall and John have strong feelings on each of these proposed libc++ and clang changes -- it would be valuable if each of you could weigh in.

After more thought i agree with @rjmccall, this is incomplete at best.
The current diff will basically kill the -Wtautological-constant-compare, introduce a lot of false-negatives, which is no-go.
On the other hand, i'm not sure that at the moment i'm able to implement what @rjmccall has outlined.
So if someone wants to take this over, let me know.

[phosek]

FWIW we've already rolled Clang that contains -Wtautological-constant-compare to our codebase and we had to set -Wno-tautological-constant-compare globally because we were getting bogus warnings in many places, similarly to D41368. If that warning ships as part of Clang 6, it's going to be be a major pain for many users so we really need some solution.

[bcain]

In D39462#959822, @phosek wrote:

FWIW we've already rolled Clang that contains -Wtautological-constant-compare to our codebase and we had to set -Wno-tautological-constant-compare globally because we were getting bogus warnings in many places, similarly to D41368. If that warning ships as part of Clang 6, it's going to be be a major pain for many users so we really need some solution.

Let's escalate this discussion to llvm-dev, then? If we don't do anything soon, it will ship w/clang 6.

[smeenai]

I posted to cfe-dev: http://lists.llvm.org/pipermail/cfe-dev/2017-December/056450.html

docs/ReleaseNotes.rst

 
 - ``-Wtautological-compare`` now warns about comparing a signed integer and 0
   when the signed integer is coerced to an unsigned type for the comparison.
   ``-Wsign-compare`` was adjusted not to warn in this case.
 
 - ``-Wtautological-constant-compare`` is a new warning that warns on
   tautological comparisons between integer variable of the type ``T`` and the
   largest/smallest possible integer constant of that same type.
+  If the tautologicalness of the comparison is data model dependent, then the
+  ``-Wmaybe-tautological-constant-compare`` (disabled by default) is used.
 
 - For C code, ``-Wsign-compare``, ``-Wsign-conversion``,
   ``-Wtautological-constant-compare`` and
   ``-Wtautological-constant-out-of-range-compare`` were adjusted to use the
   underlying datatype of ``enum``.
 
 - ``-Wnull-pointer-arithmetic`` now warns about performing pointer arithmetic
   on a null pointer. Such pointer arithmetic has an undefined behavior if the

include/clang/Basic/DiagnosticGroups.td

 def GNUStatementExpression : DiagGroup<"gnu-statement-expression">;
 def StringCompare : DiagGroup<"string-compare">;
 def StringPlusInt : DiagGroup<"string-plus-int">;
 def StringPlusChar : DiagGroup<"string-plus-char">;
 def StrncatSize : DiagGroup<"strncat-size">;
 def TautologicalUnsignedZeroCompare : DiagGroup<"tautological-unsigned-zero-compare">;
 def TautologicalUnsignedEnumZeroCompare : DiagGroup<"tautological-unsigned-enum-zero-compare">;
 def TautologicalOutOfRangeCompare : DiagGroup<"tautological-constant-out-of-range-compare">;
+def MaybeTautologicalConstantCompare : DiagGroup<"maybe-tautological-constant-compare">;
 def TautologicalConstantCompare : DiagGroup<"tautological-constant-compare",
                                             [TautologicalUnsignedZeroCompare,
                                              TautologicalUnsignedEnumZeroCompare,
-                                             TautologicalOutOfRangeCompare]>;
+                                             TautologicalOutOfRangeCompare,
+                                             MaybeTautologicalConstantCompare]>;
 def TautologicalPointerCompare : DiagGroup<"tautological-pointer-compare">;
 def TautologicalOverlapCompare : DiagGroup<"tautological-overlap-compare">;
 def TautologicalUndefinedCompare : DiagGroup<"tautological-undefined-compare">;
 def TautologicalCompare : DiagGroup<"tautological-compare",
                                     [TautologicalConstantCompare,
                                      TautologicalPointerCompare,
                                      TautologicalOverlapCompare,
                                      TautologicalUndefinedCompare]>;

include/clang/Basic/DiagnosticSemaKinds.td

 def warn_unsigned_enum_always_true_comparison : Warning<
   "comparison of %select{%3|unsigned enum expression}0 %2 "
   "%select{unsigned enum expression|%3}0 is always %select{false|true}4">,
   InGroup<TautologicalUnsignedEnumZeroCompare>;
 def warn_tautological_constant_compare : Warning<
   "comparison %select{%3|%1}0 %2 "
   "%select{%1|%3}0 is always %select{false|true}4">,
   InGroup<TautologicalConstantCompare>;
+def warn_maybe_tautological_constant_compare : Warning<
+  "for the current target platform, comparison %select{%3|%1}0 %2 "
+  "%select{%1|%3}0 is always %select{false|true}4">,
+  InGroup<MaybeTautologicalConstantCompare>, DefaultIgnore;
 
 def warn_mixed_sign_comparison : Warning<
   "comparison of integers of different signs: %0 and %1">,
   InGroup<SignCompare>, DefaultIgnore;
 def warn_out_of_range_compare : Warning<
   "comparison of %select{constant %0|true|false}1 with " 
   "%select{expression of type %2|boolean expression}3 is always "
   "%select{false|true}4">, InGroup<TautologicalOutOfRangeCompare>;

lib/Sema/SemaChecking.cpp

struct IntRange {
 
   /// True if the int is known not to have negative values.
   bool NonNegative;
 
   IntRange(unsigned Width, bool NonNegative)
     : Width(Width), NonNegative(NonNegative)
   {}
 
+  /// Indicate whether the specified integer ranges are identical.
+  friend bool operator==(const IntRange &LHS, const IntRange &RHS) {
+    return LHS.Width == RHS.Width && LHS.NonNegative == RHS.NonNegative;
+  }
+
   /// Returns the range of the bool type.
   static IntRange forBoolType() {
     return IntRange(1, true);
   }
 
   /// Returns the range of an opaque value of the given integral type.
   static IntRange forValueOfType(ASTContext &C, QualType T) {
     return forValueOfCanonicalType(C,
bool isNonBooleanUnsignedValue(Expr *E) {
   // is an integer type; and is either unsigned after implicit casts,
   // or was unsigned before implicit casts.
   return isNonBooleanIntegerValue(E) &&
          (!E->getType()->isSignedIntegerType() ||
           !E->IgnoreParenImpCasts()->getType()->isSignedIntegerType());
 }
 
 enum class LimitType {
-  Max = 1U << 0U,  // e.g. 32767 for short
-  Min = 1U << 1U,  // e.g. -32768 for short
-  Both = Max | Min // When the value is both the Min and the Max limit at the
+  None = 0,         // Just a zero-initalizer
+  Max = 1U << 0U,   // e.g. 32767 for short
+  Min = 1U << 1U,   // e.g. -32768 for short
+  Both = Max | Min, // When the value is both the Min and the Max limit at the
                     // same time; e.g. in C++, A::a in enum A { a = 0 };
+  DataModelDependent = 1U << 2U, // is this limit is always the limit, or only
+                                 // for the current data model
 };
 
+/// LimitType is a bitset, thus a few helpers are needed
+LimitType operator|(LimitType LHS, LimitType RHS) {
+  return static_cast<LimitType>(
+      static_cast<std::underlying_type<LimitType>::type>(LHS) |
+      static_cast<std::underlying_type<LimitType>::type>(RHS));
+}
+LimitType operator&(LimitType LHS, LimitType RHS) {
+  return static_cast<LimitType>(
+             static_cast<std::underlying_type<LimitType>::type>(LHS) &
+             static_cast<std::underlying_type<LimitType>::type>(RHS));
+}
+bool IsSet(llvm::Optional<LimitType> LHS, LimitType RHS) {
+  return LHS && ((*LHS) & RHS) == RHS;
+}
+
+bool HasEnumType(Expr *E) {
+  // Strip off implicit integral promotions.
+  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
+    if (ICE->getCastKind() != CK_IntegralCast &&
+        ICE->getCastKind() != CK_NoOp)
+      break;
+    E = ICE->getSubExpr();
+  }
+
+  return E->getType()->isEnumeralType();
+}
+
 /// Checks whether Expr 'Constant' may be the
 /// std::numeric_limits<>::max() or std::numeric_limits<>::min()
 /// of the Expr 'Other'. If true, then returns the limit type (min or max).
 /// The Value is the evaluation of Constant
 llvm::Optional<LimitType> IsTypeLimit(Sema &S, Expr *Constant, Expr *Other,
                                       const llvm::APSInt &Value) {
   if (IsEnumConstOrFromMacro(S, Constant))
     return llvm::Optional<LimitType>();
 
   if (isNonBooleanUnsignedValue(Other) && Value == 0)
     return LimitType::Min;
 
   // TODO: Investigate using GetExprRange() to get tighter bounds
   // on the bit ranges.
+  QualType ConstT = Constant->IgnoreParenImpCasts()->getType();
   QualType OtherT = Other->IgnoreParenImpCasts()->getType();
-  if (const auto *AT = OtherT->getAs<AtomicType>())
-    OtherT = AT->getValueType();
-
+  IntRange ConstRange = IntRange::forValueOfType(S.Context, ConstT);
   IntRange OtherRange = IntRange::forValueOfType(S.Context, OtherT);
 
   // Special-case for C++ for enum with one enumerator with value of 0.
   if (OtherRange.Width == 0)
     return Value == 0 ? LimitType::Both : llvm::Optional<LimitType>();
 
+  LimitType LT = LimitType::None;
+  if(ConstRange == OtherRange && ConstT != OtherT && !HasEnumType(Other))
+    LT = LimitType::DataModelDependent;
+
   if (llvm::APSInt::isSameValue(
           llvm::APSInt::getMaxValue(OtherRange.Width,
                                     OtherT->isUnsignedIntegerType()),
           Value))
-    return LimitType::Max;
+    return LimitType::Max | LT;
 
   if (llvm::APSInt::isSameValue(
           llvm::APSInt::getMinValue(OtherRange.Width,
                                     OtherT->isUnsignedIntegerType()),
           Value))
-    return LimitType::Min;
+    return LimitType::Min | LT;
 
   return llvm::None;
 }
 
-bool HasEnumType(Expr *E) {
-  // Strip off implicit integral promotions.
-  while (ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) {
-    if (ICE->getCastKind() != CK_IntegralCast &&
-        ICE->getCastKind() != CK_NoOp)
-      break;
-    E = ICE->getSubExpr();
-  }
-
-  return E->getType()->isEnumeralType();
-}
-
 bool CheckTautologicalComparison(Sema &S, BinaryOperator *E, Expr *Constant,
                                  Expr *Other, const llvm::APSInt &Value,
                                  bool RhsConstant) {
   // Disable warning in template instantiations
   // and only analyze <, >, <= and >= operations.
   if (S.inTemplateInstantiation() || !E->isRelationalOp())
     return false;
 
   BinaryOperatorKind Op = E->getOpcode();
 
   QualType OType = Other->IgnoreParenImpCasts()->getType();
 
   llvm::Optional<LimitType> ValueType; // Which limit (min/max) is the constant?
 
   if (!(isNonBooleanIntegerValue(Other) &&
         (ValueType = IsTypeLimit(S, Constant, Other, Value))))
     return false;
 
   bool ConstIsLowerBound = (Op == BO_LT || Op == BO_LE) ^ RhsConstant;
   bool ResultWhenConstEqualsOther = (Op == BO_LE || Op == BO_GE);
-  if (ValueType != LimitType::Both) {
+  if (!IsSet(ValueType, LimitType::Both)) {
     bool ResultWhenConstNeOther =
-        ConstIsLowerBound ^ (ValueType == LimitType::Max);
+        ConstIsLowerBound ^ IsSet(ValueType, LimitType::Max);
     if (ResultWhenConstEqualsOther != ResultWhenConstNeOther)
       return false; // The comparison is not tautological.
   } else if (ResultWhenConstEqualsOther == ConstIsLowerBound)
     return false; // The comparison is not tautological.
 
   const bool Result = ResultWhenConstEqualsOther;
 
   unsigned Diag = (isNonBooleanUnsignedValue(Other) && Value == 0)
                       ? (HasEnumType(Other)
                              ? diag::warn_unsigned_enum_always_true_comparison
                              : diag::warn_unsigned_always_true_comparison)
+                      : IsSet(ValueType, LimitType::DataModelDependent)
+                            ? diag::warn_maybe_tautological_constant_compare
                             : diag::warn_tautological_constant_compare;
 
   // Should be enough for uint128 (39 decimal digits)
   SmallString<64> PrettySourceValue;
   llvm::raw_svector_ostream OS(PrettySourceValue);
   OS << Value;
 
   S.Diag(E->getOperatorLoc(), Diag)
       << RhsConstant << OType << E->getOpcodeStr() << OS.str() << Result

test/Sema/maybe-tautological-constant-compare.c

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DLP64 -Wmaybe-tautological-constant-compare -DTEST  -verify %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DLP64 -verify %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DLP64 -Wmaybe-tautological-constant-compare -DTEST -verify -x c++ %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DLP64 -verify -x c++ %s
+// RUN: %clang_cc1 -triple i386-linux-gnu -fsyntax-only -DILP32 -Wmaybe-tautological-constant-compare -DTEST -verify %s
+// RUN: %clang_cc1 -triple i386-linux-gnu -fsyntax-only -DILP32 -verify %s
+// R1UN: %clang_cc1 -triple i386-linux-gnu -fsyntax-only -DILP32 -Wmaybe-tautological-constant-compare -DTEST -verify -x c++ %s
+// R1UN: %clang_cc1 -triple i386-linux-gnu -fsyntax-only -DILP32 -verify -x c++ %s
+
+int value(void);
+
+int main() {
+  unsigned long ul = value();
+
+#if defined(LP64)
+#if __SIZEOF_INT__ != 4
+#error Expecting 32-bit int
+#endif
+#if __SIZEOF_LONG__ != 8
+#error Expecting 64-bit int
+#endif
+#elif defined(ILP32)
+#if __SIZEOF_INT__ != 4
+#error Expecting 32-bit int
+#endif
+#if __SIZEOF_LONG__ != 4
+#error Expecting 32-bit int
+#endif
+#else
+#error LP64 or ILP32 should be defined
+#endif
+
+#if defined(LP64)
+  // expected-no-diagnostics
+
+  if (ul < 4294967295)
+    return 0;
+  if (4294967295 >= ul)
+    return 0;
+  if (ul > 4294967295)
+    return 0;
+  if (4294967295 <= ul)
+    return 0;
+  if (ul <= 4294967295)
+    return 0;
+  if (4294967295 > ul)
+    return 0;
+  if (ul >= 4294967295)
+    return 0;
+  if (4294967295 < ul)
+    return 0;
+  if (ul == 4294967295)
+    return 0;
+  if (4294967295 != ul)
+    return 0;
+  if (ul != 4294967295)
+    return 0;
+  if (4294967295 == ul)
+    return 0;
+
+  if (ul < 4294967295U)
+    return 0;
+  if (4294967295U >= ul)
+    return 0;
+  if (ul > 4294967295U)
+    return 0;
+  if (4294967295U <= ul)
+    return 0;
+  if (ul <= 4294967295U)
+    return 0;
+  if (4294967295U > ul)
+    return 0;
+  if (ul >= 4294967295U)
+    return 0;
+  if (4294967295U < ul)
+    return 0;
+  if (ul == 4294967295U)
+    return 0;
+  if (4294967295U != ul)
+    return 0;
+  if (ul != 4294967295U)
+    return 0;
+  if (4294967295U == ul)
+    return 0;
+
+  if (ul < 4294967295L)
+    return 0;
+  if (4294967295L >= ul)
+    return 0;
+  if (ul > 4294967295L)
+    return 0;
+  if (4294967295L <= ul)
+    return 0;
+  if (ul <= 4294967295L)
+    return 0;
+  if (4294967295L > ul)
+    return 0;
+  if (ul >= 4294967295L)
+    return 0;
+  if (4294967295L < ul)
+    return 0;
+  if (ul == 4294967295L)
+    return 0;
+  if (4294967295L != ul)
+    return 0;
+  if (ul != 4294967295L)
+    return 0;
+  if (4294967295L == ul)
+    return 0;
+
+  if (ul < 4294967295UL)
+    return 0;
+  if (4294967295UL >= ul)
+    return 0;
+  if (ul > 4294967295UL)
+    return 0;
+  if (4294967295UL <= ul)
+    return 0;
+  if (ul <= 4294967295UL)
+    return 0;
+  if (4294967295UL > ul)
+    return 0;
+  if (ul >= 4294967295UL)
+    return 0;
+  if (4294967295UL < ul)
+    return 0;
+  if (ul == 4294967295UL)
+    return 0;
+  if (4294967295UL != ul)
+    return 0;
+  if (ul != 4294967295UL)
+    return 0;
+  if (4294967295UL == ul)
+    return 0;
+#elif defined(ILP32)
+#if defined(TEST)
+  if (ul < 4294967295)
+    return 0;
+  if (4294967295 >= ul) // expected-warning {{comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295) // expected-warning {{comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295 <= ul)
+    return 0;
+  if (ul <= 4294967295) // expected-warning {{comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295 > ul)
+    return 0;
+  if (ul >= 4294967295)
+    return 0;
+  if (4294967295 < ul) // expected-warning {{comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295)
+    return 0;
+  if (4294967295 != ul)
+    return 0;
+  if (ul != 4294967295)
+    return 0;
+  if (4294967295 == ul)
+    return 0;
+
+  if (ul < 4294967295U)
+    return 0;
+  if (4294967295U >= ul) // expected-warning {{for the current target platform, comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295U) // expected-warning {{for the current target platform, comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295U <= ul)
+    return 0;
+  if (ul <= 4294967295U) // expected-warning {{for the current target platform, comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295U > ul)
+    return 0;
+  if (ul >= 4294967295U)
+    return 0;
+  if (4294967295U < ul) // expected-warning {{for the current target platform, comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295U)
+    return 0;
+  if (4294967295U != ul)
+    return 0;
+  if (ul != 4294967295U)
+    return 0;
+  if (4294967295U == ul)
+    return 0;
+
+  if (ul < 4294967295L)
+    return 0;
+  if (4294967295L >= ul) // expected-warning {{comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295L) // expected-warning {{comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295L <= ul)
+    return 0;
+  if (ul <= 4294967295L) // expected-warning {{comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295L > ul)
+    return 0;
+  if (ul >= 4294967295L)
+    return 0;
+  if (4294967295L < ul) // expected-warning {{comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295L)
+    return 0;
+  if (4294967295L != ul)
+    return 0;
+  if (ul != 4294967295L)
+    return 0;
+  if (4294967295L == ul)
+    return 0;
+
+  if (ul < 4294967295UL)
+    return 0;
+  if (4294967295UL >= ul) // expected-warning {{comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295UL) // expected-warning {{comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295UL <= ul)
+    return 0;
+  if (ul <= 4294967295UL) // expected-warning {{comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295UL > ul)
+    return 0;
+  if (ul >= 4294967295UL)
+    return 0;
+  if (4294967295UL < ul) // expected-warning {{comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295UL)
+    return 0;
+  if (4294967295UL != ul)
+    return 0;
+  if (ul != 4294967295UL)
+    return 0;
+  if (4294967295UL == ul)
+    return 0;
+#else // defined(TEST)
+  if (ul < 4294967295)
+    return 0;
+  if (4294967295 >= ul) // expected-warning {{comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295) // expected-warning {{comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295 <= ul)
+    return 0;
+  if (ul <= 4294967295) // expected-warning {{comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295 > ul)
+    return 0;
+  if (ul >= 4294967295)
+    return 0;
+  if (4294967295 < ul) // expected-warning {{comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295)
+    return 0;
+  if (4294967295 != ul)
+    return 0;
+  if (ul != 4294967295)
+    return 0;
+  if (4294967295 == ul)
+    return 0;
+
+  if (ul < 4294967295U)
+    return 0;
+  if (4294967295U >= ul)
+    return 0;
+  if (ul > 4294967295U)
+    return 0;
+  if (4294967295U <= ul)
+    return 0;
+  if (ul <= 4294967295U)
+    return 0;
+  if (4294967295U > ul)
+    return 0;
+  if (ul >= 4294967295U)
+    return 0;
+  if (4294967295U < ul)
+    return 0;
+  if (ul == 4294967295U)
+    return 0;
+  if (4294967295U != ul)
+    return 0;
+  if (ul != 4294967295U)
+    return 0;
+  if (4294967295U == ul)
+    return 0;
+
+  if (ul < 4294967295L)
+    return 0;
+  if (4294967295L >= ul) // expected-warning {{comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295L) // expected-warning {{comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295L <= ul)
+    return 0;
+  if (ul <= 4294967295L) // expected-warning {{comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295L > ul)
+    return 0;
+  if (ul >= 4294967295L)
+    return 0;
+  if (4294967295L < ul) // expected-warning {{comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295L)
+    return 0;
+  if (4294967295L != ul)
+    return 0;
+  if (ul != 4294967295L)
+    return 0;
+  if (4294967295L == ul)
+    return 0;
+
+  if (ul < 4294967295UL)
+    return 0;
+  if (4294967295UL >= ul) // expected-warning {{comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > 4294967295UL) // expected-warning {{comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (4294967295UL <= ul)
+    return 0;
+  if (ul <= 4294967295UL) // expected-warning {{comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (4294967295UL > ul)
+    return 0;
+  if (ul >= 4294967295UL)
+    return 0;
+  if (4294967295UL < ul) // expected-warning {{comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == 4294967295UL)
+    return 0;
+  if (4294967295UL != ul)
+    return 0;
+  if (ul != 4294967295UL)
+    return 0;
+  if (4294967295UL == ul)
+    return 0;
+#endif // defined(TEST)
+#else
+#error LP64 or ILP32 should be defined
+#endif
+
+  return 1;
+}

test/Sema/maybe-tautological-constant-compare.cpp

+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DLP64 -Wmaybe-tautological-constant-compare -DTEST -std=c++11  -verify %s
+// RUN: %clang_cc1 -triple x86_64-linux-gnu -fsyntax-only -DLP64 -std=c++11 -verify %s
+// RUN: %clang_cc1 -triple i386-linux-gnu -fsyntax-only -DILP32 -Wmaybe-tautological-constant-compare -DTEST -std=c++11 -verify %s
+// RUN: %clang_cc1 -triple i386-linux-gnu -fsyntax-only -DILP32 -std=c++11 -verify %s
+
+template <typename T> struct numeric_limits {
+  static constexpr T max() noexcept { return T(~0); }
+};
+
+int value(void);
+
+int main() {
+  unsigned long ul = value();
+
+  using T1 = unsigned int;
+  T1 t1 = value();
+  using T2 = unsigned int;
+
+#if defined(LP64)
+#if __SIZEOF_INT__ != 4
+#error Expecting 32-bit int
+#endif
+#if __SIZEOF_LONG__ != 8
+#error Expecting 64-bit int
+#endif
+#elif defined(ILP32)
+#if __SIZEOF_INT__ != 4
+#error Expecting 32-bit int
+#endif
+#if __SIZEOF_LONG__ != 4
+#error Expecting 32-bit int
+#endif
+#else
+#error LP64 or ILP32 should be defined
+#endif
+
+#if defined(TEST)
+  if (t1 < numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() >= t1) // expected-warning {{for the current target platform, comparison 4294967295 >= 'T1' (aka 'unsigned int') is always true}}
+    return 0;
+  if (t1 > numeric_limits<T1>::max()) // expected-warning {{for the current target platform, comparison 'T1' (aka 'unsigned int') > 4294967295 is always false}}
+    return 0;
+  if (numeric_limits<T1>::max() <= t1)
+    return 0;
+  if (t1 <= numeric_limits<T1>::max()) // expected-warning {{for the current target platform, comparison 'T1' (aka 'unsigned int') <= 4294967295 is always true}}
+    return 0;
+  if (numeric_limits<T1>::max() > t1)
+    return 0;
+  if (t1 >= numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() < t1) // expected-warning {{for the current target platform, comparison 4294967295 < 'T1' (aka 'unsigned int') is always false}}
+    return 0;
+  if (t1 == numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() != t1)
+    return 0;
+  if (t1 != numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() == t1)
+    return 0;
+
+  if (t1 < numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() >= t1) // expected-warning {{for the current target platform, comparison 4294967295 >= 'T1' (aka 'unsigned int') is always true}}
+    return 0;
+  if (t1 > numeric_limits<T2>::max()) // expected-warning {{for the current target platform, comparison 'T1' (aka 'unsigned int') > 4294967295 is always false}}
+    return 0;
+  if (numeric_limits<T2>::max() <= t1)
+    return 0;
+  if (t1 <= numeric_limits<T2>::max()) // expected-warning {{for the current target platform, comparison 'T1' (aka 'unsigned int') <= 4294967295 is always true}}
+    return 0;
+  if (numeric_limits<T2>::max() > t1)
+    return 0;
+  if (t1 >= numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() < t1) // expected-warning {{for the current target platform, comparison 4294967295 < 'T1' (aka 'unsigned int') is always false}}
+    return 0;
+  if (t1 == numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() != t1)
+    return 0;
+  if (t1 != numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() == t1)
+    return 0;
+#else
+  // expected-no-diagnostics
+
+  if (t1 < numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() >= t1)
+    return 0;
+  if (t1 > numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() <= t1)
+    return 0;
+  if (t1 <= numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() > t1)
+    return 0;
+  if (t1 >= numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() < t1)
+    return 0;
+  if (t1 == numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() != t1)
+    return 0;
+  if (t1 != numeric_limits<T1>::max())
+    return 0;
+  if (numeric_limits<T1>::max() == t1)
+    return 0;
+
+  if (t1 < numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() >= t1)
+    return 0;
+  if (t1 > numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() <= t1)
+    return 0;
+  if (t1 <= numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() > t1)
+    return 0;
+  if (t1 >= numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() < t1)
+    return 0;
+  if (t1 == numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() != t1)
+    return 0;
+  if (t1 != numeric_limits<T2>::max())
+    return 0;
+  if (numeric_limits<T2>::max() == t1)
+    return 0;
+#endif
+
+#if defined(ILP32) && defined(TEST)
+  if (ul < numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() >= ul) // expected-warning {{for the current target platform, comparison 4294967295 >= 'unsigned long' is always true}}
+    return 0;
+  if (ul > numeric_limits<unsigned int>::max()) // expected-warning {{for the current target platform, comparison 'unsigned long' > 4294967295 is always false}}
+    return 0;
+  if (numeric_limits<unsigned int>::max() <= ul)
+    return 0;
+  if (ul <= numeric_limits<unsigned int>::max()) // expected-warning {{for the current target platform, comparison 'unsigned long' <= 4294967295 is always true}}
+    return 0;
+  if (numeric_limits<unsigned int>::max() > ul)
+    return 0;
+  if (ul >= numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() < ul) // expected-warning {{for the current target platform, comparison 4294967295 < 'unsigned long' is always false}}
+    return 0;
+  if (ul == numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() != ul)
+    return 0;
+  if (ul != numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() == ul)
+    return 0;
+#else
+  if (ul < numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() >= ul)
+    return 0;
+  if (ul > numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() <= ul)
+    return 0;
+  if (ul <= numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() > ul)
+    return 0;
+  if (ul >= numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() < ul)
+    return 0;
+  if (ul == numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() != ul)
+    return 0;
+  if (ul != numeric_limits<unsigned int>::max())
+    return 0;
+  if (numeric_limits<unsigned int>::max() == ul)
+    return 0;
+#endif
+
+  return 1;
+}