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
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
|
// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -Wformat-pedantic -fblocks %s
// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -fblocks -std=c++98 %s
// RUN: %clang_cc1 -fsyntax-only -verify -Wformat-nonliteral -Wformat-non-iso -Wformat-pedantic -fblocks -std=c++11 %s
#include <stdarg.h>
extern "C" {
extern int scanf(const char *restrict, ...);
extern int printf(const char *restrict, ...);
extern int vprintf(const char *restrict, va_list);
}
void f(char **sp, float *fp) {
scanf("%as", sp);
#if __cplusplus <= 199711L
// expected-warning@-2 {{'a' length modifier is not supported by ISO C}}
#else
// expected-warning@-4 {{format specifies type 'float *' but the argument has type 'char **'}}
#endif
printf("%a", 1.0);
scanf("%afoobar", fp);
}
void g() {
printf("%ls", "foo"); // expected-warning{{format specifies type 'wchar_t *' but the argument has type 'const char *'}}
}
// Test that we properly handle format_idx on C++ members.
class Foo {
public:
const char *gettext(const char *fmt) __attribute__((format_arg(2)));
int scanf(const char *, ...) __attribute__((format(scanf, 2, 3)));
int printf(const char *, ...) __attribute__((format(printf, 2, 3)));
int printf2(const char *, ...);
static const char *gettext_static(const char *fmt) __attribute__((format_arg(1)));
static int printf_static(const char *fmt, ...) __attribute__((format(printf, 1, 2)));
};
void h(int *i) {
Foo foo;
foo.scanf("%d"); // expected-warning{{more '%' conversions than data arguments}}
foo.printf("%d", i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
Foo::printf_static("%d", i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
printf(foo.gettext("%d"), i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
printf(Foo::gettext_static("%d"), i); // expected-warning{{format specifies type 'int' but the argument has type 'int *'}}
}
// Test handling __null for format string literal checking.
extern "C" {
int test_null_format(const char *format, ...) __attribute__((__format__ (__printf__, 1, 2)));
#if __cplusplus >= 201103L
// expected-note@-2 {{candidate function not viable: no known conversion from 'bool' to 'const char *' for 1st argument}}
#endif
}
void rdar8269537(const char *f)
{
test_null_format(false);
#if __cplusplus <= 199711L
// expected-warning@-2 {{null from a constant boolean}}
#else
// expected-error@-4 {{no matching function for call to 'test_null_format'}}
#endif
test_null_format(0); // no-warning
test_null_format(__null); // no-warning
test_null_format(f); // expected-warning {{not a string literal}}
// expected-note@-1{{treat the string as an argument to avoid this}}
}
int Foo::printf(const char *fmt, ...) {
va_list ap;
va_start(ap,fmt);
const char * const format = fmt;
vprintf(format, ap); // no-warning
const char *format2 = fmt;
vprintf(format2, ap); // expected-warning{{format string is not a string literal}}
return 0;
}
int Foo::printf2(const char *fmt, ...) {
va_list ap;
va_start(ap,fmt);
vprintf(fmt, ap); // expected-warning{{format string is not a string literal}}
return 0;
}
namespace Templates {
template<typename T>
void my_uninstantiated_print(const T &arg) {
printf("%d", arg); // no-warning
}
template<typename T>
void my_print(const T &arg) {
printf("%d", arg); // expected-warning {{format specifies type 'int' but the argument has type 'const char *'}}
}
void use_my_print() {
my_print("abc"); // expected-note {{requested here}}
}
template<typename T>
class UninstantiatedPrinter {
public:
static void print(const T &arg) {
printf("%d", arg); // no-warning
}
};
template<typename T>
class Printer {
void format(const char *fmt, ...) __attribute__((format(printf,2,3)));
public:
void print(const T &arg) {
format("%d", arg); // expected-warning {{format specifies type 'int' but the argument has type 'const char *'}}
}
};
void use_class(Printer<const char *> &p) {
p.print("abc"); // expected-note {{requested here}}
}
extern void (^block_print)(const char * format, ...) __attribute__((format(printf, 1, 2)));
template<typename T>
void uninstantiated_call_block_print(const T &arg) {
block_print("%d", arg); // no-warning
}
template<typename T>
void call_block_print(const T &arg) {
block_print("%d", arg); // expected-warning {{format specifies type 'int' but the argument has type 'const char *'}}
}
void use_block_print() {
call_block_print("abc"); // expected-note {{requested here}}
}
}
namespace implicit_this_tests {
struct t {
void func1(const char *, ...) __attribute__((__format__(printf, 1, 2))); // expected-error {{format attribute cannot specify the implicit this argument as the format string}}
void (*func2)(const char *, ...) __attribute__((__format__(printf, 1, 2)));
static void (*func3)(const char *, ...) __attribute__((__format__(printf, 1, 2)));
static void func4(const char *, ...) __attribute__((__format__(printf, 1, 2)));
};
void f() {
t t1;
t1.func2("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}
t::func3("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}
t::func4("Hello %s"); // expected-warning {{more '%' conversions than data arguments}}
}
}
#if __cplusplus >= 201103L
namespace evaluated {
constexpr const char *basic() {
return
"%s %d"; // expected-note {{format string is defined here}}
}
constexpr const char *correct_fmt() {
return
"%d %d";
}
constexpr const char *string_linebreak() {
return
"%d %d"
"%d %s"; // expected-note {{format string is defined here}}
}
/*non-constexpr*/ const char *not_literal() {
return
"%d %d"
"%d %s";
}
constexpr const char *inner_call() {
return "%d %s"; // expected-note {{format string is defined here}}
}
constexpr const char *wrap_constexpr() {
return inner_call();
}
void f() {
printf(basic(), 1, 2); // expected-warning {{format specifies type 'char *' but the argument has type 'int'}}
printf(correct_fmt(), 1, 2);
printf(string_linebreak(), 1, 2, 3, 4); // expected-warning {{format specifies type 'char *' but the argument has type 'int'}}
printf(not_literal(), 1, 2, 3, 4); // expected-warning {{format string is not a string literal}}
printf(wrap_constexpr(), 1, 2); // expected-warning {{format specifies type 'char *' but the argument has type 'int'}}
constexpr const char *fmt {"%d%d"};
printf(fmt, 1, 1); // no-warning
constexpr const char *fmt2 {"%d"}; // expected-note{{format string is defined here}}
printf(fmt2, "oops"); // expected-warning{{format specifies type 'int' but the argument has type}}
}
}
namespace ScopedEnumerations {
enum class Scoped1 { One };
enum class Scoped2 : unsigned short { Two };
void f(Scoped1 S1, Scoped2 S2) {
printf("%hhd", S1); // expected-warning {{format specifies type 'char' but the argument has type 'Scoped1'}}
printf("%hd", S1); // expected-warning {{format specifies type 'short' but the argument has type 'Scoped1'}}
printf("%d", S1); // expected-warning {{format specifies type 'int' but the argument has type 'Scoped1'}}
printf("%hhd", S2); // expected-warning {{format specifies type 'char' but the argument has type 'Scoped2'}}
printf("%hd", S2); // expected-warning {{format specifies type 'short' but the argument has type 'Scoped2'}}
printf("%d", S2); // expected-warning {{format specifies type 'int' but the argument has type 'Scoped2'}}
scanf("%hhd", &S1); // expected-warning {{format specifies type 'char *' but the argument has type 'Scoped1 *'}}
scanf("%hd", &S1); // expected-warning {{format specifies type 'short *' but the argument has type 'Scoped1 *'}}
scanf("%d", &S1); // expected-warning {{format specifies type 'int *' but the argument has type 'Scoped1 *'}}
scanf("%hhd", &S2); // expected-warning {{format specifies type 'char *' but the argument has type 'Scoped2 *'}}
scanf("%hd", &S2); // expected-warning {{format specifies type 'short *' but the argument has type 'Scoped2 *'}}
scanf("%d", &S2); // expected-warning {{format specifies type 'int *' but the argument has type 'Scoped2 *'}}
}
}
#endif
|
