[analyzer] CStringChecker: Warning text fixes.

[NoQ]

Summary

Fixes the problem mentioned in D66333#1726488. Additionally refers to strcat as "memory concatenation function" as opposed to "memory copy functions".

TODO: Add a flag to VerifyDiagnosticConsumer to match full messages by default.

[Charusso]

Cool, thanks!

[xazax.hun]

Cool! :)

clang/lib/StaticAnalyzer/Checkers/CStringChecker.cpp

ProgramStateRef CStringChecker::checkNonNull(CheckerContext &C,
   ProgramStateRef stateNull, stateNonNull;
   std::tie(stateNull, stateNonNull) = assumeZero(C, state, l, S->getType());
 
   if (stateNull && !stateNonNull) {
     if (Filter.CheckCStringNullArg) {
       SmallString<80> buf;
       llvm::raw_svector_ostream OS(buf);
       assert(CurrentFunctionDescription);
-      OS << "Null pointer argument in call to " << CurrentFunctionDescription
-         << ' ' << IdxOfArg << llvm::getOrdinalSuffix(IdxOfArg)
-         << " parameter";
+      OS << "Null pointer passed as " << IdxOfArg
+         << llvm::getOrdinalSuffix(IdxOfArg) << " argument to "
+         << CurrentFunctionDescription;
 
       emitNullArgBug(C, stateNull, S, OS.str());
     }
     return nullptr;
   }
 
   // From here on, assume that the value is non-null.
   assert(stateNonNull);
evalStrcpyCommon(C, CE,
                    /* appendK = */ ConcatFnKind::strlcat,
                    /* returnPtr = */ false);
 }
 
 void CStringChecker::evalStrcpyCommon(CheckerContext &C, const CallExpr *CE,
                                       bool ReturnEnd, bool IsBounded,
                                       ConcatFnKind appendK,
                                       bool returnPtr) const {
+  if (appendK == ConcatFnKind::none)
     CurrentFunctionDescription = "string copy function";
+  else
+    CurrentFunctionDescription = "string concatenation function";
   ProgramStateRef state = C.getState();
   const LocationContext *LCtx = C.getLocationContext();
 
   // Check that the destination is non-null.
   const Expr *Dst = CE->getArg(0);
   SVal DstVal = state->getSVal(Dst, LCtx);
 
   state = checkNonNull(C, state, Dst, DstVal, 1);

clang/test/Analysis/bsd-string.c

 
 void f3() {
   char dst[2];
   const char *src = "abdef";
   strlcpy(dst, src, 5); // expected-warning{{Size argument is greater than the length of the destination buffer}}
 }
 
 void f4() {
-  strlcpy(NULL, "abcdef", 6); // expected-warning{{Null pointer argument in call to string copy function}}
+  strlcpy(NULL, "abcdef", 6); // expected-warning{{Null pointer passed as 1st argument to string copy function}}
 }
 
 void f5() {
-  strlcat(NULL, "abcdef", 6); // expected-warning{{Null pointer argument in call to string copy function}}
+  strlcat(NULL, "abcdef", 6); // expected-warning{{Null pointer passed as 1st argument to string concatenation function}}
 }
 
 void f6() {
   char buf[8];
   strlcpy(buf, "abc", 3);
   size_t len = strlcat(buf, "defg", 4);
   clang_analyzer_eval(len == 7); // expected-warning{{TRUE}}
 }

clang/test/Analysis/bstring.c

 void memcpy9() {
   int a[4] = {0};
   memcpy(a+2, a+1, 4); // no-warning
   memcpy(a+1, a+2, 4); // no-warning
 }
 
 void memcpy10() {
   char a[4] = {0};
-  memcpy(0, a, 4); // expected-warning{{Null pointer argument in call to memory copy function}}
+  memcpy(0, a, 4); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void memcpy11() {
   char a[4] = {0};
-  memcpy(a, 0, 4); // expected-warning{{Null pointer argument in call to memory copy function}}
+  memcpy(a, 0, 4); // expected-warning{{Null pointer passed as 2nd argument to memory copy function}}
 }
 
 void memcpy12() {
   char a[4] = {0};
   memcpy(0, a, 0); // no-warning
 }
 
 void memcpy13() {
   char a[4] = {0};
   memcpy(a, 0, 0); // no-warning
 }
 
 void memcpy_unknown_size (size_t n) {
   char a[4], b[4] = {1};
   clang_analyzer_eval(memcpy(a, b, n) == a); // expected-warning{{TRUE}}
 }
 
 void memcpy_unknown_size_warn (size_t n) {
   char a[4];
-  void *result = memcpy(a, 0, n); // expected-warning{{Null pointer argument in call to memory copy function}}
+  void *result = memcpy(a, 0, n); // expected-warning{{Null pointer passed as 2nd argument to memory copy function}}
   clang_analyzer_eval(result == a); // no-warning (above is fatal)
 }
 
 //===----------------------------------------------------------------------===
 // mempcpy()
 //===----------------------------------------------------------------------===
 
 #ifdef VARIANT

 void mempcpy9() {
   int a[4] = {0};
   mempcpy(a+2, a+1, 4); // no-warning
   mempcpy(a+1, a+2, 4); // no-warning
 }
 
 void mempcpy10() {
   char a[4] = {0};
-  mempcpy(0, a, 4); // expected-warning{{Null pointer argument in call to memory copy function}}
+  mempcpy(0, a, 4); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void mempcpy11() {
   char a[4] = {0};
-  mempcpy(a, 0, 4); // expected-warning{{Null pointer argument in call to memory copy function}}
+  mempcpy(a, 0, 4); // expected-warning{{Null pointer passed as 2nd argument to memory copy function}}
 }
 
 void mempcpy12() {
   char a[4] = {0};
   mempcpy(0, a, 0); // no-warning
 }
 
 void mempcpy13() {
void mempcpy16() {
   p1 = (&s2[0]) + 5;
   p2 = mempcpy(&s2[0], &s1[0], 5 * sizeof(struct st));
 
   clang_analyzer_eval(p1 == p2); // expected-warning{{TRUE}}
 }
 
 void mempcpy_unknown_size_warn (size_t n) {
   char a[4];
-  void *result = mempcpy(a, 0, n); // expected-warning{{Null pointer argument in call to memory copy function}}
+  void *result = mempcpy(a, 0, n); // expected-warning{{Null pointer passed as 2nd argument to memory copy function}}
   clang_analyzer_eval(result == a); // no-warning (above is fatal)
 }
 
 void mempcpy_unknownable_size (char *src, float n) {
   char a[4];
   // This used to crash because we don't model floats.
   mempcpy(a, src, (size_t)n);
 }

clang/test/Analysis/cstring-ranges.c

 // RUN: %clang_analyze_cc1 -analyzer-checker=unix.cstring -analyzer-output=text %s 2>&1 | FileCheck %s
 
 // This test verifies argument source range highlighting.
 // Otherwise we've no idea which of the arguments is null.
+// These days we actually also have it in the message,
+// but the range is still great to have.
 
 char *strcpy(char *, const char *);
 
 void foo() {
   char *a = 0, *b = 0;
   strcpy(a, b);
 }
 
-// CHECK: warning: Null pointer argument in call to string copy function
+// CHECK: warning: Null pointer passed as 1st argument to string copy function
 // CHECK-NEXT: strcpy(a, b);
 // CHECK-NEXT: ^      ~

clang/test/Analysis/null-deref-path-notes.c

 // RUN: %clang_analyze_cc1 -w -x c -analyzer-checker=core,unix -analyzer-output=text -verify %s
 
 // Avoid the crash when finding the expression for tracking the origins
 // of the null pointer for path notes.
 void pr34373() {
   int *a = 0; // expected-note{{'a' initialized to a null pointer value}}
   (a + 0)[0]; // expected-warning{{Array access results in a null pointer dereference}}
               // expected-note@-1{{Array access results in a null pointer dereference}}
 }
 
 typedef __typeof(sizeof(int)) size_t;
 void *memcpy(void *dest, const void *src, unsigned long count);
 
 void f1(char *source) {
   char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}}
-  memcpy(destination + 0, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}}
-                                       // expected-note@-1{{Null pointer argument in call to memory copy function}}
+  memcpy(destination + 0, source, 10); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
+                                       // expected-note@-1{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void f2(char *source) {
   char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}}
-  memcpy(destination - 0, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}}
-                                       // expected-note@-1{{Null pointer argument in call to memory copy function}}
+  memcpy(destination - 0, source, 10); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
+                                       // expected-note@-1{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void f3(char *source) {
   char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}}
   destination = destination + 0; // expected-note{{Null pointer value stored to 'destination'}}
-  memcpy(destination, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}}
-                                   // expected-note@-1{{Null pointer argument in call to memory copy function}}
+  memcpy(destination, source, 10); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
+                                   // expected-note@-1{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void f4(char *source) {
   char *destination = 0; // expected-note{{'destination' initialized to a null pointer value}}
   destination = destination - 0; // expected-note{{Null pointer value stored to 'destination'}}
-  memcpy(destination, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}}
-                                   // expected-note@-1{{Null pointer argument in call to memory copy function}}
+  memcpy(destination, source, 10); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
+                                   // expected-note@-1{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void f5(char *source) {
   char *destination1 = 0; // expected-note{{'destination1' initialized to a null pointer value}}
   char *destination2 = destination1 + 0; // expected-note{{'destination2' initialized to a null pointer value}}
-  memcpy(destination2, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}}
-                                    // expected-note@-1{{Null pointer argument in call to memory copy function}}
+  memcpy(destination2, source, 10); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
+                                    // expected-note@-1{{Null pointer passed as 1st argument to memory copy function}}
 }
 
 void f6(char *source) {
   char *destination1 = 0; // expected-note{{'destination1' initialized to a null pointer value}}
   char *destination2 = destination1 - 0; // expected-note{{'destination2' initialized to a null pointer value}}
-  memcpy(destination2, source, 10); // expected-warning{{Null pointer argument in call to memory copy function}}
-                                    // expected-note@-1{{Null pointer argument in call to memory copy function}}
+  memcpy(destination2, source, 10); // expected-warning{{Null pointer passed as 1st argument to memory copy function}}
+                                    // expected-note@-1{{Null pointer passed as 1st argument to memory copy function}}
 }

clang/test/Analysis/null-deref-ps-region.c

void bar() {
   int *x = malloc(sizeof(int));
   memset(x, 0, 1);
   int n = 1 / *x; // no-warning
   free(x);
 }
 
 void testConcreteNull() {
   int *x = 0;
-  memset(x, 0, 1); // expected-warning {{Null pointer argument in call to memory set function}}
+  memset(x, 0, 1); // expected-warning {{Null pointer passed as 1st argument to memory set function}}
 }
 
 void testStackArray() {
   char buf[13];
   memset(buf, 0, 1); // no-warning
 }
 
 void testHeapSymbol() {

clang/test/Analysis/string.c

void strlen_constant2(char x) {
   char a[] = "123";
   clang_analyzer_eval(strlen(a) == 3); // expected-warning{{TRUE}}
 
   a[0] = x;
   clang_analyzer_eval(strlen(a) == 3); // expected-warning{{UNKNOWN}}
 }
 
 size_t strlen_null() {
-  return strlen(0); // expected-warning{{Null pointer argument in call to string length function}}
+  return strlen(0); // expected-warning{{Null pointer passed as 1st argument to string length function}}
 }
 
 size_t strlen_fn() {
   return strlen((char*)&strlen_fn); // expected-warning{{Argument to string length function is the address of the function 'strlen_fn', which is not a null-terminated string}}
 }
 
 size_t strlen_nonloc() {
 label:

 void strnlen_constant6(char x) {
   char a[] = "123456";
   clang_analyzer_eval(strnlen(a, 3) == 3); // expected-warning{{TRUE}}
   a[0] = x;
   clang_analyzer_eval(strnlen(a, 3) == 3); // expected-warning{{UNKNOWN}}
 }
 
 size_t strnlen_null() {
-  return strnlen(0, 3); // expected-warning{{Null pointer argument in call to string length function}}
+  return strnlen(0, 3); // expected-warning{{Null pointer passed as 1st argument to string length function}}
 }
 
 size_t strnlen_fn() {
   return strnlen((char*)&strlen_fn, 3); // expected-warning{{Argument to string length function is the address of the function 'strlen_fn', which is not a null-terminated string}}
 }
 
 size_t strnlen_nonloc() {
 label:

 
 #define strcpy BUILTIN(strcpy)
 char *strcpy(char *restrict s1, const char *restrict s2);
 
 #endif /* VARIANT */
 
 
 void strcpy_null_dst(char *x) {
-  strcpy(NULL, x); // expected-warning{{Null pointer argument in call to string copy function}}
+  strcpy(NULL, x); // expected-warning{{Null pointer passed as 1st argument to string copy function}}
 }
 
 void strcpy_null_src(char *x) {
-  strcpy(x, NULL); // expected-warning{{Null pointer argument in call to string copy function}}
+  strcpy(x, NULL); // expected-warning{{Null pointer passed as 2nd argument to string copy function}}
 }
 
 void strcpy_fn(char *x) {
   strcpy(x, (char*)&strcpy_fn); // expected-warning{{Argument to string copy function is the address of the function 'strcpy_fn', which is not a null-terminated string}}
 }
 
 void strcpy_fn_const(char *x) {
   strcpy(x, (const char*)&strcpy_fn); // expected-warning{{Argument to string copy function is the address of the function 'strcpy_fn', which is not a null-terminated string}}

 
 #define strcat BUILTIN(strcat)
 char *strcat(char *restrict s1, const char *restrict s2);
 
 #endif /* VARIANT */
 
 
 void strcat_null_dst(char *x) {
-  strcat(NULL, x); // expected-warning{{Null pointer argument in call to string copy function}}
+  strcat(NULL, x); // expected-warning{{Null pointer passed as 1st argument to string concatenation function}}
 }
 
 void strcat_null_src(char *x) {
-  strcat(x, NULL); // expected-warning{{Null pointer argument in call to string copy function}}
+  strcat(x, NULL); // expected-warning{{Null pointer passed as 2nd argument to string concatenation function}}
 }
 
 void strcat_fn(char *x) {
-  strcat(x, (char*)&strcat_fn); // expected-warning{{Argument to string copy function is the address of the function 'strcat_fn', which is not a null-terminated string}}
+  strcat(x, (char*)&strcat_fn); // expected-warning{{Argument to string concatenation function is the address of the function 'strcat_fn', which is not a null-terminated string}}
 }
 
 void strcat_effects(char *y) {
   char x[8] = "123";
   size_t orig_len = strlen(x);
   char a = x[0];
 
   if (strlen(y) != 4)

 
 #define strncpy BUILTIN(strncpy)
 char *strncpy(char *restrict s1, const char *restrict s2, size_t n);
 
 #endif /* VARIANT */
 
 
 void strncpy_null_dst(char *x) {
-  strncpy(NULL, x, 5); // expected-warning{{Null pointer argument in call to string copy function}}
+  strncpy(NULL, x, 5); // expected-warning{{Null pointer passed as 1st argument to string copy function}}
 }
 
 void strncpy_null_src(char *x) {
-  strncpy(x, NULL, 5); // expected-warning{{Null pointer argument in call to string copy function}}
+  strncpy(x, NULL, 5); // expected-warning{{Null pointer passed as 2nd argument to string copy function}}
 }
 
 void strncpy_fn(char *x) {
   strncpy(x, (char*)&strcpy_fn, 5); // expected-warning{{Argument to string copy function is the address of the function 'strcpy_fn', which is not a null-terminated string}}
 }
 
 void strncpy_effects(char *x, char *y) {
   char a = x[0];

 
 #define strncat BUILTIN(strncat)
 char *strncat(char *restrict s1, const char *restrict s2, size_t n);
 
 #endif /* VARIANT */
 
 
 void strncat_null_dst(char *x) {
-  strncat(NULL, x, 4); // expected-warning{{Null pointer argument in call to string copy function}}
+  strncat(NULL, x, 4); // expected-warning{{Null pointer passed as 1st argument to string concatenation function}}
 }
 
 void strncat_null_src(char *x) {
-  strncat(x, NULL, 4); // expected-warning{{Null pointer argument in call to string copy function}}
+  strncat(x, NULL, 4); // expected-warning{{Null pointer passed as 2nd argument to string concatenation function}}
 }
 
 void strncat_fn(char *x) {
-  strncat(x, (char*)&strncat_fn, 4); // expected-warning{{Argument to string copy function is the address of the function 'strncat_fn', which is not a null-terminated string}}
+  strncat(x, (char*)&strncat_fn, 4); // expected-warning{{Argument to string concatenation function is the address of the function 'strncat_fn', which is not a null-terminated string}}
 }
 
 void strncat_effects(char *y) {
   char x[8] = "123";
   size_t orig_len = strlen(x);
   char a = x[0];
 
   if (strlen(y) != 4)
void strcmp_2() {
   char *x = "123";
   char *y = "234";
   clang_analyzer_eval(strcmp(x, y) < 0); // expected-warning{{TRUE}}
 }
 
 void strcmp_null_0() {
   char *x = NULL;
   char *y = "123";
-  strcmp(x, y); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strcmp(x, y); // expected-warning{{Null pointer passed as 1st argument to string comparison function}}
 }
 
 void strcmp_null_1() {
   char *x = "123";
   char *y = NULL;
-  strcmp(x, y); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strcmp(x, y); // expected-warning{{Null pointer passed as 2nd argument to string comparison function}}
 }
 
 void strcmp_diff_length_0() {
   char *x = "12345";
   char *y = "234";
   clang_analyzer_eval(strcmp(x, y) < 0); // expected-warning{{TRUE}}
 }
 
void strncmp_2() {
   char *x = "123";
   char *y = "234";
   clang_analyzer_eval(strncmp(x, y, 3) < 0); // expected-warning{{TRUE}}
 }
 
 void strncmp_null_0() {
   char *x = NULL;
   char *y = "123";
-  strncmp(x, y, 3); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strncmp(x, y, 3); // expected-warning{{Null pointer passed as 1st argument to string comparison function}}
 }
 
 void strncmp_null_1() {
   char *x = "123";
   char *y = NULL;
-  strncmp(x, y, 3); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strncmp(x, y, 3); // expected-warning{{Null pointer passed as 2nd argument to string comparison function}}
 }
 
 void strncmp_diff_length_0() {
   char *x = "12345";
   char *y = "234";
   clang_analyzer_eval(strncmp(x, y, 5) < 0); // expected-warning{{TRUE}}
 }
 
void strcasecmp_2() {
   char *x = "abc";
   char *y = "Bcd";
   clang_analyzer_eval(strcasecmp(x, y) < 0); // expected-warning{{TRUE}}
 }
 
 void strcasecmp_null_0() {
   char *x = NULL;
   char *y = "123";
-  strcasecmp(x, y); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strcasecmp(x, y); // expected-warning{{Null pointer passed as 1st argument to string comparison function}}
 }
 
 void strcasecmp_null_1() {
   char *x = "123";
   char *y = NULL;
-  strcasecmp(x, y); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strcasecmp(x, y); // expected-warning{{Null pointer passed as 2nd argument to string comparison function}}
 }
 
 void strcasecmp_diff_length_0() {
   char *x = "abcde";
   char *y = "aBd";
   clang_analyzer_eval(strcasecmp(x, y) < 0); // expected-warning{{TRUE}}
 }
 
void strncasecmp_2() {
   char *x = "abc";
   char *y = "Bcd";
   clang_analyzer_eval(strncasecmp(x, y, 3) < 0); // expected-warning{{TRUE}}
 }
 
 void strncasecmp_null_0() {
   char *x = NULL;
   char *y = "123";
-  strncasecmp(x, y, 3); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strncasecmp(x, y, 3); // expected-warning{{Null pointer passed as 1st argument to string comparison function}}
 }
 
 void strncasecmp_null_1() {
   char *x = "123";
   char *y = NULL;
-  strncasecmp(x, y, 3); // expected-warning{{Null pointer argument in call to string comparison function}}
+  strncasecmp(x, y, 3); // expected-warning{{Null pointer passed as 2nd argument to string comparison function}}
 }
 
 void strncasecmp_diff_length_0() {
   char *x = "abcde";
   char *y = "aBd";
   clang_analyzer_eval(strncasecmp(x, y, 5) < 0); // expected-warning{{TRUE}}
 }
 

 
 //===----------------------------------------------------------------------===
 // strsep()
 //===----------------------------------------------------------------------===
 
 char *strsep(char **stringp, const char *delim);
 
 void strsep_null_delim(char *s) {
-  strsep(&s, NULL); // expected-warning{{Null pointer argument in call to strsep()}}
+  strsep(&s, NULL); // expected-warning{{Null pointer passed as 2nd argument to strsep()}}
 }
 
 void strsep_null_search() {
-  strsep(NULL, ""); // expected-warning{{Null pointer argument in call to strsep()}}
+  strsep(NULL, ""); // expected-warning{{Null pointer passed as 1st argument to strsep()}}
 }
 
 void strsep_return_original_pointer(char *s) {
   char *original = s;
   char *result = strsep(&s, ""); // no-warning
   clang_analyzer_eval(original == result); // expected-warning{{TRUE}}
 }
 
void memset26_upper_UCHAR_MAX() {
 
   clang_analyzer_eval(strlen(array) == 0); // expected-warning{{TRUE}}
   clang_analyzer_eval(array[4] == 0); // expected-warning{{TRUE}}
 }
 
 void bzero1_null() {
   char *a = NULL;
 
-  bzero(a, 10); // expected-warning{{Null pointer argument in call to memory clearance function}}
+  bzero(a, 10); // expected-warning{{Null pointer passed as 1st argument to memory clearance function}}
 }
 
 void bzero2_char_array_null() {
   char str[] = "abcd";
   clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}}
   bzero(str, 2);
   clang_analyzer_eval(strlen(str) == 0); // expected-warning{{TRUE}}
 }
 
 void bzero3_char_ptr_null() {
   char *str = "abcd";
   clang_analyzer_eval(strlen(str) == 4); // expected-warning{{TRUE}}
   bzero(str + 2, 2);
   clang_analyzer_eval(strlen(str) == 0); // expected-warning{{FALSE}}
 }
 
 void explicit_bzero1_null() {
   char *a = NULL;
 
-  explicit_bzero(a, 10); // expected-warning{{Null pointer argument in call to memory clearance function}}
+  explicit_bzero(a, 10); // expected-warning{{Null pointer passed as 1st argument to memory clearance function}}
 }
 
 void explicit_bzero2_clear_mypassword() {
   char passwd[7] = "passwd";
 
   explicit_bzero(passwd, sizeof(passwd)); // no-warning
 
   clang_analyzer_eval(strlen(passwd) == 0); // expected-warning{{TRUE}}