PR16074, implement warnings to catch pointer to boolean true and pointer to

null comparison when the pointer is known to be non-null.

This catches the array to pointer decay, function to pointer decay and
address of variables.  This does not catch address of function since this
has been previously used to silence a warning.

Pointer to bool conversion is under -Wbool-conversion.
Pointer to null comparison is under -Wtautological-pointer-compare, a sub-group
of -Wtautological-compare.

void foo() {
  int arr[5];
  int x;
  // warn on these conditionals
  if (foo);
  if (arr);
  if (&x);
  if (foo == null);
  if (arr == null);
  if (&x == null);

  if (&foo);  // no warning
}

llvm-svn: 202216

1 files changed, 111 insertions, 0 deletions

diff --git a/clang/test/SemaCXX/warn-tautological-compare.cpp b/clang/test/SemaCXX/warn-tautological-compare.cpp
index caea6bf86e0..b44f3f9d8fa 100644
--- a/clang/test/SemaCXX/warn-tautological-compare.cpp
+++ b/clang/test/SemaCXX/warn-tautological-compare.cpp
@@ -25,3 +25,114 @@ namespace RuntimeBehavior {
     if (x < kintmax) {}
   }
 }
+
+namespace ArrayCompare {
+  #define GetValue(ptr)  ((ptr != 0) ? ptr[0] : 0)
+  extern int a[] __attribute__((weak));
+  int b[] = {8,13,21};
+  struct {
+    int x[10];
+  } c;
+  const char str[] = "text";
+  void ignore() {
+    if (a == 0) {}
+    if (a != 0) {}
+    (void)GetValue(b);
+  }
+  void test() {
+    if (b == 0) {}
+    // expected-warning@-1{{comparison of array 'b' equal to a null pointer is always false}}
+    if (b != 0) {}
+    // expected-warning@-1{{comparison of array 'b' not equal to a null pointer is always true}}
+    if (0 == b) {}
+    // expected-warning@-1{{comparison of array 'b' equal to a null pointer is always false}}
+    if (0 != b) {}
+    // expected-warning@-1{{comparison of array 'b' not equal to a null pointer is always true}}
+    if (c.x == 0) {}
+    // expected-warning@-1{{comparison of array 'c.x' equal to a null pointer is always false}}
+    if (c.x != 0) {}
+    // expected-warning@-1{{comparison of array 'c.x' not equal to a null pointer is always true}}
+    if (str == 0) {}
+    // expected-warning@-1{{comparison of array 'str' equal to a null pointer is always false}}
+    if (str != 0) {}
+    // expected-warning@-1{{comparison of array 'str' not equal to a null pointer is always true}}
+  }
+}
+
+namespace FunctionCompare {
+  #define CallFunction(f) ((f != 0) ? f() : 0)
+  extern void a()  __attribute__((weak));
+  void fun1();
+  int fun2();
+  int* fun3();
+  int* fun4(int);
+  class S {
+  public:
+    static int foo();
+  };
+  void ignore() {
+    if (a == 0) {}
+    if (0 != a) {}
+    (void)CallFunction(fun2);
+  }
+  void test() {
+    if (fun1 == 0) {}
+    // expected-warning@-1{{comparison of function 'fun1' equal to a null pointer is always false}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    if (fun2 == 0) {}
+    // expected-warning@-1{{comparison of function 'fun2' equal to a null pointer is always false}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    // expected-note@-3{{suffix with parentheses to turn this into a function call}}
+    if (fun3 == 0) {}
+    // expected-warning@-1{{comparison of function 'fun3' equal to a null pointer is always false}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    // expected-note@-3{{suffix with parentheses to turn this into a function call}}
+    if (fun4 == 0) {}
+    // expected-warning@-1{{comparison of function 'fun4' equal to a null pointer is always false}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    if (nullptr != fun1) {}
+    // expected-warning@-1{{comparison of function 'fun1' not equal to a null pointer is always true}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    if (nullptr != fun2) {}
+    // expected-warning@-1{{comparison of function 'fun2' not equal to a null pointer is always true}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    if (nullptr != fun3) {}
+    // expected-warning@-1{{comparison of function 'fun3' not equal to a null pointer is always true}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    // expected-note@-3{{suffix with parentheses to turn this into a function call}}
+    if (nullptr != fun4) {}
+    // expected-warning@-1{{comparison of function 'fun4' not equal to a null pointer is always true}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    if (S::foo == 0) {}
+    // expected-warning@-1{{comparison of function 'S::foo' equal to a null pointer is always false}}
+    // expected-note@-2{{prefix with the address-of operator to silence this warning}}
+    // expected-note@-3{{suffix with parentheses to turn this into a function call}}
+  }
+}
+
+namespace PointerCompare {
+  extern int a __attribute__((weak));
+  int b;
+  static int c;
+  class S {
+  public:
+    static int a;
+    int b;
+  };
+  void ignored() {
+    if (&a == 0) {}
+  }
+  void test() {
+    S s;
+    if (&b == 0) {}
+    // expected-warning@-1{{comparison of address of 'b' equal to a null pointer is always false}}
+    if (&c == 0) {}
+    // expected-warning@-1{{comparison of address of 'c' equal to a null pointer is always false}}
+    if (&s.a == 0) {}
+    // expected-warning@-1{{comparison of address of 's.a' equal to a null pointer is always false}}
+    if (&s.b == 0) {}
+    // expected-warning@-1{{comparison of address of 's.b' equal to a null pointer is always false}}
+    if (&S::a == 0) {}
+    // expected-warning@-1{{comparison of address of 'S::a' equal to a null pointer is always false}}
+  }
+}