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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
|
// RUN: %clang_cc1 -triple x86_64-apple-darwin10 -analyze -analyzer-checker=unix.API,osx.API %s -analyzer-store=region -fblocks -verify
struct _opaque_pthread_once_t {
long __sig;
char __opaque[8];
};
typedef struct _opaque_pthread_once_t __darwin_pthread_once_t;
typedef __darwin_pthread_once_t pthread_once_t;
int pthread_once(pthread_once_t *, void (*)(void));
typedef long unsigned int __darwin_size_t;
typedef __darwin_size_t size_t;
void *calloc(size_t, size_t);
void *malloc(size_t);
void *realloc(void *, size_t);
void *alloca(size_t);
void *valloc(size_t);
typedef void (^dispatch_block_t)(void);
typedef long dispatch_once_t;
void dispatch_once(dispatch_once_t *predicate, dispatch_block_t block);
#ifndef O_CREAT
#define O_CREAT 0x0200
#define O_RDONLY 0x0000
#endif
int open(const char *, int, ...);
int close(int fildes);
void test_open(const char *path) {
int fd;
fd = open(path, O_RDONLY); // no-warning
if (!fd)
close(fd);
fd = open(path, O_CREAT); // expected-warning{{Call to 'open' requires a third argument when the 'O_CREAT' flag is set}}
if (!fd)
close(fd);
}
void test_dispatch_once() {
dispatch_once_t pred = 0;
do { if (__builtin_expect(*(&pred), ~0l) != ~0l) dispatch_once((&pred), (^() {})); } while (0); // expected-warning{{Call to 'dispatch_once' uses the local variable 'pred' for the predicate value}}
}
void test_dispatch_once_neg() {
static dispatch_once_t pred = 0;
do { if (__builtin_expect(*(&pred), ~0l) != ~0l) dispatch_once((&pred), (^() {})); } while (0); // no-warning
}
void test_pthread_once_aux();
void test_pthread_once() {
pthread_once_t pred = {0x30B1BCBA, {0}};
pthread_once(&pred, test_pthread_once_aux); // expected-warning{{Call to 'pthread_once' uses the local variable 'pred' for the "control" value}}
}
void test_pthread_once_neg() {
static pthread_once_t pred = {0x30B1BCBA, {0}};
pthread_once(&pred, test_pthread_once_aux); // no-warning
}
// PR 2899 - warn of zero-sized allocations to malloc().
void pr2899() {
char* foo = malloc(0); // expected-warning{{Call to 'malloc' has an allocation size of 0 bytes}}
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void pr2899_nowarn(size_t size) {
char* foo = malloc(size); // no-warning
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_calloc(void) {
char *foo = calloc(0, 42); // expected-warning{{Call to 'calloc' has an allocation size of 0 bytes}}
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_calloc2(void) {
char *foo = calloc(42, 0); // expected-warning{{Call to 'calloc' has an allocation size of 0 bytes}}
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_calloc_nowarn(size_t nmemb, size_t size) {
char *foo = calloc(nmemb, size); // no-warning
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_realloc(char *ptr) {
char *foo = realloc(ptr, 0); // expected-warning{{Call to 'realloc' has an allocation size of 0 bytes}}
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_realloc_nowarn(char *ptr, size_t size) {
char *foo = realloc(ptr, size); // no-warning
for (unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_alloca() {
char *foo = alloca(0); // expected-warning{{Call to 'alloca' has an allocation size of 0 bytes}}
for(unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_alloca_nowarn(size_t sz) {
char *foo = alloca(sz); // no-warning
for(unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_builtin_alloca() {
char *foo2 = __builtin_alloca(0); // expected-warning{{Call to 'alloca' has an allocation size of 0 bytes}}
for(unsigned i = 0; i < 100; i++) {
foo2[i] = 0;
}
}
void test_builtin_alloca_nowarn(size_t sz) {
char *foo2 = __builtin_alloca(sz); // no-warning
for(unsigned i = 0; i < 100; i++) {
foo2[i] = 0;
}
}
void test_valloc() {
char *foo = valloc(0); // expected-warning{{Call to 'valloc' has an allocation size of 0 bytes}}
for(unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
void test_valloc_nowarn(size_t sz) {
char *foo = valloc(sz); // no-warning
for(unsigned i = 0; i < 100; i++) {
foo[i] = 0;
}
}
|
