blob: 38e84e17cee00070d7a4c3ed224341ceee3777bc (
plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
|
// RUN: %clang_cc1 -analyze -analyzer-checker=core,unix.Malloc -analyzer-store=region -analyzer-max-loop 4 -verify %s
#include "Inputs/system-header-simulator.h"
typedef __typeof(sizeof(int)) size_t;
void *malloc(size_t);
static int another_function(int *y) {
if (*y > 0)
return *y;
return 0;
}
static void function_which_doesnt_give_up(int **x) {
*x = 0;
}
static void function_which_gives_up(int *x) {
for (int i = 0; i < 5; ++i)
(*x)++;
}
static void function_which_gives_up_nested(int *x) {
function_which_gives_up(x);
for (int i = 0; i < 5; ++i)
(*x)++;
}
static void function_which_doesnt_give_up_nested(int *x, int *y) {
*y = another_function(x);
function_which_gives_up(x);
}
void coverage1(int *x) {
function_which_gives_up(x);
char *m = (char*)malloc(12);
} // expected-warning {{potential leak}}
void coverage2(int *x) {
if (x) {
function_which_gives_up(x);
char *m = (char*)malloc(12);
}
} // expected-warning {{potential leak}}
void coverage3(int *x) {
x++;
function_which_gives_up(x);
char *m = (char*)malloc(12);
} // expected-warning {{potential leak}}
void coverage4(int *x) {
*x += another_function(x);
function_which_gives_up(x);
char *m = (char*)malloc(12);
} // expected-warning {{potential leak}}
void coverage5(int *x) {
for (int i = 0; i<7; ++i)
function_which_gives_up(x);
// The root function gives up here.
char *m = (char*)malloc(12); // no-warning
}
void coverage6(int *x) {
for (int i = 0; i<3; ++i) {
function_which_gives_up(x);
}
char *m = (char*)malloc(12);
} // expected-warning {{potential leak}}
int coverage7_inline(int *i) {
function_which_doesnt_give_up(&i);
return *i; // expected-warning {{Dereference}}
}
void coverage8(int *x) {
int y;
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}}
void function_which_gives_up_settonull(int **x) {
*x = 0;
int y = 0;
for (int i = 0; i < 5; ++i)
y++;
}
void coverage9(int *x) {
int y = 5;
function_which_gives_up_settonull(&x);
y = (*x); // no warning
}
static void empty_function(){
}
int use_empty_function(int x) {
x = 0;
empty_function();
return 5/x; //expected-warning {{Division by zero}}
}
|
