// RUN: rm -f %t
-// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc -analyzer-output=plist -o %t %s
+// RUN: %clang_analyze_cc1 -fblocks -analyzer-checker=core,unix.Malloc -analyzer-output=plist -verify -o %t %s
// RUN: FileCheck -input-file %t %s
typedef __typeof(sizeof(int)) size_t;
void myArrayAllocation() {
int **A;
A = malloc(2*sizeof(int*));
- A[0] = 0;// expected-warning {{leak}}
-}
+ A[0] = 0;
+}//expected-warning{{Potential leak}}
void reallocDiagnostics() {
char * buf = malloc(100);
void test_wrapper() {
void *buf = wrapper();
(void) buf;
-}
+}//expected-warning{{Potential leak}}
// Test what happens when the same call frees and allocated memory.
// Also tests the stack hint for parameters, when they are passed directly or via pointer.
void *test_double_action_call() {
void *buf;
my_malloc_and_free(&buf);
- return buf;
+ return buf; //expected-warning{{Use of memory after it is freed}}
}
// Test stack hint for 'reallocation failed'.
void reallocIntra() {
char *buf = (char *)malloc(100);
buf = my_realloc(buf);
- free(buf);
+ free(buf);//expected-warning{{Potential leak}}
}
// Test stack hint when returning a result.
void use_ret() {
char *v;
v = malloc_wrapper_ret();
-}
+}//expected-warning{{Potential leak}}
// Passing a block as a parameter to an inlined call for which we generate
// a stack hint message caused crashes.
int *p = malloc(sizeof(int));
myfree_takingblock(some_block, p);
- *p = 3;
+ *p = 3;//expected-warning{{Use of memory after it is freed}}
}
// Test that we refer to the last symbol used in the leak diagnostic.
m = p;
p = 0;
(*m)++;
- in++;
+ in++;//expected-warning{{Potential leak}}
}
// Tests that exercise running remove dead bindings at Call exit.
static void function_with_leak1() {
char *x = (char*)malloc(12);
-}
+} //expected-warning{{Potential leak}}
void use_function_with_leak1() {
function_with_leak1();
int y = 0;
static void function_with_leak2() {
char *x = (char*)malloc(12);
- int m = 0;
+ int m = 0; //expected-warning{{Potential leak}}
}
void use_function_with_leak2() {
function_with_leak2();
char *x = (char*)malloc(12);
if (y)
y++;
-}
+}//expected-warning{{Potential leak}}
void use_function_with_leak3(int y) {
function_with_leak3(y);
}
if (y)
y++;
else
- y--;
+ y--;//expected-warning{{Potential leak}}
}
void use_function_with_leak4(int y) {
function_with_leak4(y);
}
static int function_with_leak5() {
char *x = (char*)malloc(12);
- return anotherFunction5();
+ return anotherFunction5();//expected-warning{{Potential leak}}
}
void use_function_with_leak5() {
function_with_leak5();
}
static void function_with_leak6() {
char *x = (char*)malloc(12);
- anotherFunction6(3);
+ anotherFunction6(3);//expected-warning{{Potential leak}}
}
void use_function_with_leak6() {
function_with_leak6();
}
void use_function_with_leak7() {
function_with_leak7();
-}
+}//expected-warning{{Potential memory leak}}
// Test that we do not print the name of a variable not visible from where
// the issue is reported.
}
void testOnlyRefferToVisibleVariables() {
my_malloc();
-} // expected-warning {{Potential leak of memory}}
+} // expected-warning{{Potential memory leak}}
struct PointerWrapper{
int*p;
return w.p;
}
void testMyMalloc() {
- my_malloc_into_struct(); // expected-warning {{Potential leak of memory}}
-}
+ my_malloc_into_struct();
+} // expected-warning{{Potential memory leak}}
// CHECK: <key>diagnostics</key>
// CHECK-NEXT: <array>