dnrops
/
clang
mirror of https://github.com/microsoft/clang.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

[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
This commit is contained in:
Anna Zaks 2013-04-06 00:41:36 +00:00
parent cb3443925f
commit 68eb4c25e9
13 changed files with 103 additions and 102 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/StaticAnalyzer/Checkers/MallocChecker.cpp
View File

@ -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,

4
test/Analysis/Malloc+MismatchedDeallocator+NewDelete.cpp
View File

@ -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() {

2
test/Analysis/Malloc+NewDelete_intersections.cpp
View File

@ -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'}}

12
test/Analysis/NewDelete-checker-test.cpp
View File

@ -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

10
test/Analysis/NewDelete-custom.cpp
View File

@ -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

6
test/Analysis/NewDelete-intersections.mm
View File

@ -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
}

12
test/Analysis/coverage.c
View File

@ -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;

14
test/Analysis/malloc-annotations.c
View File

@ -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() {

8
test/Analysis/malloc-interprocedural.c
View File

@ -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;'

84
test/Analysis/malloc-plist.c
View File

@ -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>

44
test/Analysis/malloc.c
View File

@ -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() {

2
test/Analysis/new.cpp
View File

@ -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));

2
test/Analysis/objc-boxing.m
View File

@ -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) {