[analyzer] Shorten the malloc checker’s leak message

As per Ted’s suggestion!

git-svn-id: https://llvm.org/svn/llvm-project/cfe/trunk@178938 91177308-0d34-0410-b5e6-96231b3b80d8

diff --git a/lib/StaticAnalyzer/Checkers/MallocChecker.cpp b/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
index a1ec819ef287e6004b4ebff391e94dc24b12cade..51205d863abff320bb9a1fae1f8c8df976d966e0 100644 (file)
--- a/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
+++ b/lib/StaticAnalyzer/Checkers/MallocChecker.cpp
@@ -1585,11 +1585,12 @@ void MallocChecker::reportLeak(SymbolRef Sym, ExplodedNode *N,
 
   SmallString<200> buf;
   llvm::raw_svector_ostream os(buf);
-  os << "Memory is never released; potential leak";
   if (Region && Region->canPrintPretty()) {
-    os << " of memory pointed to by '";
+    os << "Potential leak of memory pointed to by '";
     Region->printPretty(os);
     os << '\'';
+  } else {
+    os << "Potential memory leak";
   }
 
   BugReport *R = new BugReport(*BT_Leak, os.str(), N, 

diff --git a/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp b/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp
index b7a9cc0ba6ce2098513f021418b793542c4845bf..666ff966fec325bd6c20a1d1d02734f51b52c14b 100644 (file)
--- a/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp
+++ b/test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp
@@ -16,7 +16,7 @@ void testMallocDoubleFree() {
 
 void testMallocLeak() {
   int *p = (int *)malloc(sizeof(int));
-} // expected-warning{{Memory is never released; potential leak of memory pointed to by 'p'}}
+} // expected-warning{{Potential leak of memory pointed to by 'p'}}
 
 void testMallocUseAfterFree() {
   int *p = (int *)malloc(sizeof(int));
@@ -55,7 +55,7 @@ void testNewLeak() {
   int *p = new int;
 }
 #ifdef LEAKS
-// expected-warning@-2 {{Memory is never released; potential leak of memory pointed to by 'p'}}
+// expected-warning@-2 {{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testNewUseAfterFree() {

diff --git a/test/Analysis/Malloc+NewDelete_intersections.cpp b/test/Analysis/Malloc+NewDelete_intersections.cpp
index 5ce9e3c53531fb844256e0366de360856de36f09..310663646a109af64ea56eb132ab20234d58fa25 100644 (file)
--- a/test/Analysis/Malloc+NewDelete_intersections.cpp
+++ b/test/Analysis/Malloc+NewDelete_intersections.cpp
@@ -12,4 +12,4 @@ void free(void *);
 void testMismatchedDeallocator() {
   int *p = (int *)malloc(sizeof(int));
   delete p;
-} // expected-warning{{Memory is never released; potential leak of memory pointed to by 'p'}}
+} // expected-warning{{Potential leak of memory pointed to by 'p'}}

diff --git a/test/Analysis/NewDelete-checker-test.cpp b/test/Analysis/NewDelete-checker-test.cpp
index 0c69aa10a9cb717366c17ea2c8b3ce6156ff4857..bf95221eac8922096bbcee855b2226adf8f3d589 100644 (file)
--- a/test/Analysis/NewDelete-checker-test.cpp
+++ b/test/Analysis/NewDelete-checker-test.cpp
@@ -15,28 +15,28 @@ void testGlobalOpNew() {
   void *p = operator new(0);
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testGlobalOpNewArray() {
   void *p = operator new[](0);
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testGlobalNewExpr() {
   int *p = new int;
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testGlobalNewExprArray() {
   int *p = new int[0];
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 //----- Standard nothrow placement operators
@@ -44,14 +44,14 @@ void testGlobalNoThrowPlacementOpNewBeforeOverload() {
   void *p = operator new(0, std::nothrow);
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testGlobalNoThrowPlacementExprNewBeforeOverload() {
   int *p = new(std::nothrow) int;
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 

diff --git a/test/Analysis/NewDelete-custom.cpp b/test/Analysis/NewDelete-custom.cpp
index 2dadb210faec04c78befdfded2e581d09ec1c120..c64bfce2dee39ff9ef4c4ea41074a07a203cff3f 100644 (file)
--- a/test/Analysis/NewDelete-custom.cpp
+++ b/test/Analysis/NewDelete-custom.cpp
@@ -27,7 +27,7 @@ void testNewMethod() {
   C *c3 = ::new C;
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'c3'}}
 #endif
 
 void testOpNewArray() {
@@ -38,7 +38,7 @@ void testNewExprArray() {
   int *p = new int[0];
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 
@@ -51,7 +51,7 @@ void testNewExpr() {
   int *p = new int;
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 
@@ -60,14 +60,14 @@ void testOpNewNoThrow() {
   void *p = operator new(0, std::nothrow);
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testNewExprNoThrow() {
   int *p = new(std::nothrow) int;
 }
 #ifdef LEAKS
-// expected-warning@-2{{Memory is never released; potential leak}}
+// expected-warning@-2{{Potential leak of memory pointed to by 'p'}}
 #endif
 
 //----- Custom placement operators

diff --git a/test/Analysis/NewDelete-intersections.mm b/test/Analysis/NewDelete-intersections.mm
index 9e14aa8b8629628b59a4be53074275a9ba0d92a5..9024ed57668b89ce8c9b2d3402b037784265c123 100644 (file)
--- a/test/Analysis/NewDelete-intersections.mm
+++ b/test/Analysis/NewDelete-intersections.mm
@@ -42,7 +42,7 @@ void testFreeOpNew() {
   free(p);
 }
 #ifdef LEAKS
-// expected-warning@-2 {{Memory is never released; potential leak}}
+// expected-warning@-2 {{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testFreeNewExpr() {
@@ -50,14 +50,14 @@ void testFreeNewExpr() {
   free(p);
 }
 #ifdef LEAKS
-// expected-warning@-2 {{Memory is never released; potential leak}}
+// expected-warning@-2 {{Potential leak of memory pointed to by 'p'}}
 #endif
 
 void testObjcFreeNewed() {
   int *p = new int;
   NSData *nsdata = [NSData dataWithBytesNoCopy:p length:sizeof(int) freeWhenDone:1];
 #ifdef LEAKS
-  // expected-warning@-2 {{Memory is never released; potential leak}}
+  // expected-warning@-2 {{Potential leak of memory pointed to by 'p'}}
 #endif
 }
 

diff --git a/test/Analysis/coverage.c b/test/Analysis/coverage.c
index 38e84e17cee00070d7a4c3ed224341ceee3777bc..9e437d21827254dc3d6def082a07b979dbd0f67f 100644 (file)
--- a/test/Analysis/coverage.c
+++ b/test/Analysis/coverage.c
@@ -33,26 +33,26 @@ static void function_which_doesnt_give_up_nested(int *x, int *y) {
 void coverage1(int *x) {
   function_which_gives_up(x);
   char *m = (char*)malloc(12);
-} // expected-warning {{potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by 'm'}}
 
 void coverage2(int *x) {
   if (x) {
     function_which_gives_up(x);
     char *m = (char*)malloc(12);
   }
-} // expected-warning {{potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by 'm'}}
 
 void coverage3(int *x) {
   x++;
   function_which_gives_up(x);
   char *m = (char*)malloc(12);
-} // expected-warning {{potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by 'm'}}
 
 void coverage4(int *x) {
   *x += another_function(x);
   function_which_gives_up(x);
   char *m = (char*)malloc(12);
-} // expected-warning {{potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by 'm'}}
 
 void coverage5(int *x) {
   for (int i = 0; i<7; ++i)
@@ -66,7 +66,7 @@ void coverage6(int *x) {
     function_which_gives_up(x);
   }
   char *m = (char*)malloc(12);
-} // expected-warning {{potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by 'm'}}
 
 int coverage7_inline(int *i) {
   function_which_doesnt_give_up(&i);
@@ -78,7 +78,7 @@ void coverage8(int *x) {
   function_which_doesnt_give_up_nested(x, &y);
   y = (*x)/y;  // expected-warning {{Division by zero}}
   char *m = (char*)malloc(12);
-} // expected-warning {{potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by 'm'}}
 
 void function_which_gives_up_settonull(int **x) {
   *x = 0;

diff --git a/test/Analysis/malloc-annotations.c b/test/Analysis/malloc-annotations.c
index 3a260c3aefd4b7229ef79637b877c2787352c826..c197df4386e8f9af52b37b5e13dcf02fcfa4a11f 100644 (file)
--- a/test/Analysis/malloc-annotations.c
+++ b/test/Analysis/malloc-annotations.c
@@ -26,7 +26,7 @@ struct stuff myglobalstuff;
 
 void f1() {
   int *p = malloc(12);
-  return; // expected-warning{{Memory is never released; potential leak}}
+  return; // expected-warning{{Potential leak of memory pointed to by}}
 }
 
 void f2() {
@@ -54,17 +54,17 @@ void naf1() {
 
 void n2af1() {
   int *p = my_malloc2(12);
-  return; // expected-warning{{Memory is never released; potential leak}}
+  return; // expected-warning{{Potential leak of memory pointed to by}}
 }
 
 void af1() {
   int *p = my_malloc(12);
-  return; // expected-warning{{Memory is never released; potential leak}}
+  return; // expected-warning{{Potential leak of memory pointed to by}}
 }
 
 void af1_b() {
   int *p = my_malloc(12);
-} // expected-warning{{Memory is never released; potential leak}}
+} // expected-warning{{Potential leak of memory pointed to by}}
 
 void af1_c() {
   myglobalpointer = my_malloc(12); // no-warning
@@ -73,7 +73,7 @@ void af1_c() {
 void af1_d() {
   struct stuff mystuff;
   mystuff.somefield = my_malloc(12);
-} // expected-warning{{Memory is never released; potential leak}}
+} // expected-warning{{Potential leak of memory pointed to by}}
 
 // Test that we can pass out allocated memory via pointer-to-pointer.
 void af1_e(void **pp) {
@@ -239,7 +239,7 @@ char mallocGarbage () {
 // This tests that calloc() buffers need to be freed
 void callocNoFree () {
   char *buf = calloc(2,2);
-  return; // expected-warning{{never released}}
+  return; // expected-warning{{Potential leak of memory pointed to by}}
 }
 
 // These test that calloc() buffers are zeroed by default
@@ -258,7 +258,7 @@ char callocZeroesBad () {
   if (buf[1] != 0) {
     free(buf); // expected-warning{{never executed}}
   }
-  return result; // expected-warning{{never released}}
+  return result; // expected-warning{{Potential leak of memory pointed to by}}
 }
 
 void testMultipleFreeAnnotations() {

diff --git a/test/Analysis/malloc-interprocedural.c b/test/Analysis/malloc-interprocedural.c
index 3c7bab6717c2d55a66b6fc9e9979cb1a195a05a1..c78cc6c6aae44fac2cb56d4896985e49d6411c9c 100644 (file)
--- a/test/Analysis/malloc-interprocedural.c
+++ b/test/Analysis/malloc-interprocedural.c
@@ -32,7 +32,7 @@ static void my_free1(void *p) {
 static void test1() {
   void *data = 0;
   my_malloc1(&data, 4);
-} // expected-warning {{Memory is never released; potential leak of memory pointed to by 'data'}}
+} // expected-warning {{Potential leak of memory pointed to by 'data'}}
 
 static void test11() {
   void *data = 0;
@@ -43,9 +43,9 @@ static void test11() {
 static void testUniqueingByallocationSiteInTopLevelFunction() {
   void *data = my_malloc2(1, 4);
   data = 0;
-  int x = 5;// expected-warning {{Memory is never released; potential leak of memory pointed to by 'data'}}
+  int x = 5;// expected-warning {{Potential leak of memory pointed to by 'data'}}
   data = my_malloc2(1, 4);
-} // expected-warning {{Memory is never released; potential leak of memory pointed to by 'data'}}
+} // expected-warning {{Potential leak of memory pointed to by 'data'}}
 
 static void test3() {
   void *data = my_malloc2(1, 4);
@@ -81,7 +81,7 @@ static char *reshape(char *in) {
 void testThatRemoveDeadBindingsRunBeforeEachCall() {
     char *v = malloc(12);
     v = reshape(v);
-    v = reshape(v);// expected-warning {{Memory is never released; potential leak of memory pointed to by 'v'}}
+    v = reshape(v);// expected-warning {{Potential leak of memory pointed to by 'v'}}
 }
 
 // Test that we keep processing after 'return;'

diff --git a/test/Analysis/malloc-plist.c b/test/Analysis/malloc-plist.c
index ddd09db6ff86becc1fa79ed870dffeda783e622c..419a7684a1aa5a421182bfe35b73eed03b45ab31 100644 (file)
--- a/test/Analysis/malloc-plist.c
+++ b/test/Analysis/malloc-plist.c
@@ -378,12 +378,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;p&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;p&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;p&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;p&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;p&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;p&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -540,12 +540,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;A&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;A&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;A&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;A&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;A&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;A&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -925,12 +925,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -1324,12 +1324,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -2403,12 +2403,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;buf&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;buf&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -2671,12 +2671,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;v&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;v&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;v&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;v&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;v&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;v&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -2833,12 +2833,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;m&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;m&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;m&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;m&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;m&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;m&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -3038,12 +3038,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -3243,12 +3243,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -3545,12 +3545,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -3847,12 +3847,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -4052,12 +4052,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -4257,12 +4257,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>1</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:      <string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak of memory pointed to by &apos;x&apos;</string>
+// CHECK-NEXT:    <key>description</key><string>Potential leak of memory pointed to by &apos;x&apos;</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>
@@ -4491,12 +4491,12 @@ void use_function_with_leak7() {
 // CHECK-NEXT:      </dict>
 // CHECK-NEXT:      <key>depth</key><integer>0</integer>
 // CHECK-NEXT:      <key>extended_message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak</string>
+// CHECK-NEXT:      <string>Potential memory leak</string>
 // CHECK-NEXT:      <key>message</key>
-// CHECK-NEXT:      <string>Memory is never released; potential leak</string>
+// CHECK-NEXT:      <string>Potential memory leak</string>
 // CHECK-NEXT:     </dict>
 // CHECK-NEXT:    </array>
-// CHECK-NEXT:    <key>description</key><string>Memory is never released; potential leak</string>
+// CHECK-NEXT:    <key>description</key><string>Potential memory leak</string>
 // CHECK-NEXT:    <key>category</key><string>Memory Error</string>
 // CHECK-NEXT:    <key>type</key><string>Memory leak</string>
 // CHECK-NEXT:   <key>issue_context_kind</key><string>function</string>

diff --git a/test/Analysis/malloc.c b/test/Analysis/malloc.c
index 7790b32b078ec6a5210be86182fe41794afc6bf6..fae3a4dddbdac1468639ae5c1d1a2e97a59e8289 100644 (file)
--- a/test/Analysis/malloc.c
+++ b/test/Analysis/malloc.c
@@ -21,7 +21,7 @@ char *fooRetPtr();
 
 void f1() {
   int *p = malloc(12);
-  return; // expected-warning{{Memory is never released; potential leak of memory pointed to by 'p'}}
+  return; // expected-warning{{Potential leak of memory pointed to by 'p'}}
 }
 
 void f2() {
@@ -46,7 +46,7 @@ void reallocNotNullPtr(unsigned sizeIn) {
   char *p = (char*)malloc(size);
   if (p) {
     char *q = (char*)realloc(p, sizeIn);
-    char x = *q; // expected-warning {{Memory is never released; potential leak of memory pointed to by 'q'}}
+    char x = *q; // expected-warning {{Potential leak of memory pointed to by 'q'}}
   }
 }
 
@@ -105,7 +105,7 @@ void reallocSizeZero5() {
 
 void reallocPtrZero1() {
   char *r = realloc(0, 12);
-} // expected-warning {{Memory is never released; potential leak of memory pointed to by 'r'}}
+} // expected-warning {{Potential leak of memory pointed to by 'r'}}
 
 void reallocPtrZero2() {
   char *r = realloc(0, 12);
@@ -122,7 +122,7 @@ void reallocRadar6337483_1() {
     char *buf = malloc(100);
     buf = (char*)realloc(buf, 0x1000000);
     if (!buf) {
-        return;// expected-warning {{Memory is never released; potential leak}}
+        return;// expected-warning {{Potential leak of memory pointed to by}}
     }
     free(buf);
 }
@@ -135,7 +135,7 @@ void reallocRadar6337483_2() {
     } else {
       free(buf2);
     }
-} // expected-warning {{Memory is never released; potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by}}
 
 void reallocRadar6337483_3() {
     char * buf = malloc(100);
@@ -153,7 +153,7 @@ void reallocRadar6337483_4() {
     char *buf = malloc(100);
     char *buf2 = (char*)realloc(buf, 0x1000000);
     if (!buf2) {
-      return;  // expected-warning {{Memory is never released; potential leak}}
+      return;  // expected-warning {{Potential leak of memory pointed to by}}
     } else {
       free(buf2);
     }
@@ -189,7 +189,7 @@ void reallocfRadar6337483_3() {
 
 void reallocfPtrZero1() {
   char *r = reallocf(0, 12);
-} // expected-warning {{Memory is never released; potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by}}
 
 
 // This case tests that storing malloc'ed memory to a static variable which is
@@ -293,7 +293,7 @@ char mallocGarbage () {
 // This tests that calloc() buffers need to be freed
 void callocNoFree () {
   char *buf = calloc(2,2);
-  return; // expected-warning{{never released}}
+  return; // expected-warning{{Potential leak of memory pointed to by 'buf'}}
 }
 
 // These test that calloc() buffers are zeroed by default
@@ -312,7 +312,7 @@ char callocZeroesBad () {
        if (buf[1] != 0) {
          free(buf); // expected-warning{{never executed}}
        }
-       return result; // expected-warning{{never released}}
+       return result; // expected-warning{{Potential leak of memory pointed to by 'buf'}}
 }
 
 void nullFree() {
@@ -387,12 +387,12 @@ void mallocEscapeMalloc() {
   int *p = malloc(12);
   myfoo(p);
   p = malloc(12);
-} // expected-warning{{Memory is never released; potential leak}}
+} // expected-warning{{Potential leak of memory pointed to by}}
 
 void mallocMalloc() {
   int *p = malloc(12);
   p = malloc(12);
-} // expected-warning {{Memory is never released; potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by}}
 
 void mallocFreeMalloc() {
   int *p = malloc(12);
@@ -451,7 +451,7 @@ void mallocFailedOrNotLeak() {
   if (p == 0)
     return; // no warning
   else
-    return; // expected-warning {{Memory is never released; potential leak}}
+    return; // expected-warning {{Potential leak of memory pointed to by}}
 }
 
 void mallocAssignment() {
@@ -461,7 +461,7 @@ void mallocAssignment() {
 
 int vallocTest() {
   char *mem = valloc(12);
-  return 0; // expected-warning {{Memory is never released; potential leak}}
+  return 0; // expected-warning {{Potential leak of memory pointed to by}}
 }
 
 void vallocEscapeFreeUse() {
@@ -534,7 +534,7 @@ int *testMalloc3() {
 void testStructLeak() {
   StructWithPtr St;
   St.memP = malloc(12);
-  return; // expected-warning {{Memory is never released; potential leak of memory pointed to by 'St.memP'}}
+  return; // expected-warning {{Potential leak of memory pointed to by 'St.memP'}}
 }
 
 void testElemRegion1() {
@@ -584,7 +584,7 @@ struct X* RegInvalidationDetect1(struct X *s2) {
   struct X *px= malloc(sizeof(struct X));
   px->p = 0;
   px = s2;
-  return px; // expected-warning {{Memory is never released; potential leak}}
+  return px; // expected-warning {{Potential leak of memory pointed to by}}
 }
 
 struct X* RegInvalidationGiveUp1() {
@@ -598,7 +598,7 @@ int **RegInvalidationDetect2(int **pp) {
   int *p = malloc(12);
   pp = &p;
   pp++;
-  return 0;// expected-warning {{Memory is never released; potential leak}}
+  return 0;// expected-warning {{Potential leak of memory pointed to by}}
 }
 
 extern void exit(int) __attribute__ ((__noreturn__));
@@ -674,7 +674,7 @@ int *specialMallocWithStruct() {
 void testStrdup(const char *s, unsigned validIndex) {
   char *s2 = strdup(s);
   s2[validIndex + 1] = 'b';
-} // expected-warning {{Memory is never released; potential leak}}
+} // expected-warning {{Potential leak of memory pointed to by}}
 
 int testStrndup(const char *s, unsigned validIndex, unsigned size) {
   char *s2 = strndup(s, size);
@@ -682,7 +682,7 @@ int testStrndup(const char *s, unsigned validIndex, unsigned size) {
   if (s2[validIndex] != 'a')
     return 0;
   else
-    return 1;// expected-warning {{Memory is never released; potential leak}}
+    return 1;// expected-warning {{Potential leak of memory pointed to by}}
 }
 
 void testStrdupContentIsDefined(const char *s, unsigned validIndex) {
@@ -945,7 +945,7 @@ void localStructTest() {
   StructWithPtr St;
   StructWithPtr *pSt = &St;
   pSt->memP = malloc(12);
-} // expected-warning{{Memory is never released; potential leak}}
+} // expected-warning{{Potential leak of memory pointed to by}}
 
 #ifdef __INTPTR_TYPE__
 // Test double assignment through integers.
@@ -1067,14 +1067,14 @@ void testPassConstPointerIndirectlyStruct() {
   struct HasPtr hp;
   hp.p = malloc(10);
   memcmp(&hp, &hp, sizeof(hp));
-  return; // expected-warning {{Memory is never released; potential leak of memory pointed to by 'hp.p'}}
+  return; // expected-warning {{Potential leak of memory pointed to by 'hp.p'}}
 }
 
 void testPassToSystemHeaderFunctionIndirectlyStruct() {
   SomeStruct ss;
   ss.p = malloc(1);
   fakeSystemHeaderCall(&ss);
-} // expected-warning {{Memory is never released; potential leak of memory pointed to by 'ss.p'}}
+} // expected-warning {{Potential leak of memory pointed to by 'ss.p'}}
 
 int *testOffsetAllocate(size_t size) {
   int *memoryBlock = (int *)malloc(size + sizeof(int));
@@ -1160,7 +1160,7 @@ void testOffsetZeroDoubleFree() {
 void testOffsetPassedToStrlen() {
   char * string = malloc(sizeof(char)*10);
   string += 1;
-  int length = strlen(string); // expected-warning {{Memory is never released; potential leak of memory pointed to by 'string'}}
+  int length = strlen(string); // expected-warning {{Potential leak of memory pointed to by 'string'}}
 }
 
 void testOffsetPassedToStrlenThenFree() {

diff --git a/test/Analysis/new.cpp b/test/Analysis/new.cpp
index 44ae9802f81f55fdb25e464177a05a04b876c0c1..802243088e9b9d05878c2cd16ef67fa0ef3e89c2 100644 (file)
--- a/test/Analysis/new.cpp
+++ b/test/Analysis/new.cpp
@@ -126,7 +126,7 @@ void testNewDeleteNoWarn() {
 void testDeleteMallocked() {
   int *x = (int *)malloc(sizeof(int));
   delete x; // FIXME: Shoud detect pointer escape and keep silent after 'delete' is modeled properly.
-} // expected-warning{{Memory is never released; potential leak}}
+} // expected-warning{{Potential leak of memory pointed to by 'x'}}
 
 void testDeleteOpAfterFree() {
   int *p = (int *)malloc(sizeof(int));

diff --git a/test/Analysis/objc-boxing.m b/test/Analysis/objc-boxing.m
index 16915788d63a09c934fda971c2327ef4c759063d..98310b52f49dff18f9ad176458270d1628210901 100644 (file)
--- a/test/Analysis/objc-boxing.m
+++ b/test/Analysis/objc-boxing.m
@@ -34,7 +34,7 @@ id constant_string() {
 }
 
 id dynamic_string() {
-    return @(strdup("boxed dynamic string")); // expected-warning{{Memory is never released; potential leak}}
+    return @(strdup("boxed dynamic string")); // expected-warning{{Potential memory leak}}
 }
 
 id const_char_pointer(int *x) {