|
111
|
1 /* Test -Wsizeof-pointer-memaccess warnings. */
|
|
|
2 /* { dg-do compile } */
|
|
131
|
3 /* { dg-options "-Wall -Wno-array-bounds -Wno-sizeof-array-argument -Wno-stringop-overflow -Wno-stringop-truncation" } */
|
|
111
|
4 /* Test just twice, once with -O0 non-fortified, once with -O2 fortified. */
|
|
|
5 /* { dg-skip-if "" { *-*-* } { "*" } { "-O0" "-O2" } } */
|
|
|
6 /* { dg-skip-if "" { *-*-* } { "-flto" } { "" } } */
|
|
|
7 /* { dg-require-effective-target alloca } */
|
|
|
8
|
|
|
9 typedef __SIZE_TYPE__ size_t;
|
|
|
10 extern void *memset (void *, int, size_t);
|
|
|
11 extern void *memcpy (void *__restrict, const void *__restrict, size_t);
|
|
|
12 extern void *memmove (void *__restrict, const void *__restrict, size_t);
|
|
|
13 extern int memcmp (const void *, const void *, size_t);
|
|
|
14 extern char *strncpy (char *__restrict, const char *__restrict, size_t);
|
|
|
15 extern char *strncat (char *__restrict, const char *__restrict, size_t);
|
|
|
16 extern char *stpncpy (char *__restrict, const char *__restrict, size_t);
|
|
|
17 extern char *strndup (const char *, size_t);
|
|
|
18 extern int strncmp (const char *, const char *, size_t);
|
|
|
19 extern int strncasecmp (const char *, const char *, size_t);
|
|
|
20
|
|
|
21 #ifdef __OPTIMIZE__
|
|
|
22 # define bos(ptr) __builtin_object_size (ptr, 1)
|
|
|
23 # define bos0(ptr) __builtin_object_size (ptr, 0)
|
|
|
24
|
|
|
25 __attribute__((__always_inline__, __gnu_inline__, __artificial__))
|
|
|
26 extern inline void *
|
|
|
27 memset (void *dest, int c, size_t len)
|
|
|
28 {
|
|
|
29 return __builtin___memset_chk (dest, c, len, bos0 (dest));
|
|
|
30 }
|
|
|
31
|
|
|
32 __attribute__((__always_inline__, __gnu_inline__, __artificial__))
|
|
|
33 extern inline void *
|
|
|
34 memcpy (void *__restrict dest, const void *__restrict src, size_t len)
|
|
|
35 {
|
|
|
36 return __builtin___memcpy_chk (dest, src, len, bos0 (dest));
|
|
|
37 }
|
|
|
38
|
|
|
39 __attribute__((__always_inline__, __gnu_inline__, __artificial__))
|
|
|
40 extern inline void *
|
|
|
41 memmove (void *dest, const void *src, size_t len)
|
|
|
42 {
|
|
|
43 return __builtin___memmove_chk (dest, src, len, bos0 (dest));
|
|
|
44 }
|
|
|
45
|
|
|
46 __attribute__((__always_inline__, __gnu_inline__, __artificial__))
|
|
|
47 extern inline char *
|
|
|
48 strncpy (char *__restrict dest, const char *__restrict src, size_t len)
|
|
|
49 {
|
|
|
50 return __builtin___strncpy_chk (dest, src, len, bos (dest));
|
|
|
51 }
|
|
|
52
|
|
|
53 __attribute__((__always_inline__, __gnu_inline__, __artificial__))
|
|
|
54 extern inline char *
|
|
|
55 strncat (char *dest, const char *src, size_t len)
|
|
|
56 {
|
|
|
57 return __builtin___strncat_chk (dest, src, len, bos (dest));
|
|
|
58 }
|
|
|
59
|
|
|
60 __attribute__((__always_inline__, __gnu_inline__, __artificial__))
|
|
|
61 extern inline char *
|
|
|
62 stpncpy (char *__restrict dest, const char *__restrict src, size_t len)
|
|
|
63 {
|
|
|
64 return __builtin___stpncpy_chk (dest, src, len, bos (dest));
|
|
|
65 }
|
|
|
66 #endif
|
|
|
67
|
|
|
68 struct A { short a, b; int c, d; long e, f; };
|
|
|
69 typedef struct A TA;
|
|
|
70 typedef struct A *PA;
|
|
|
71 typedef TA *PTA;
|
|
|
72 struct B {};
|
|
|
73 typedef struct B TB;
|
|
|
74 typedef struct B *PB;
|
|
|
75 typedef TB *PTB;
|
|
|
76 typedef int X[3][3][3];
|
|
|
77
|
|
|
78 int
|
|
|
79 f1 (void *x, int z)
|
|
|
80 {
|
|
|
81 struct A a, *pa1 = &a;
|
|
|
82 TA *pa2 = &a;
|
|
|
83 PA pa3 = &a;
|
|
|
84 PTA pa4 = &a;
|
|
|
85 memset (&a, 0, sizeof (&a)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
86 memset (pa1, 0, sizeof (pa1)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
87 memset (pa2, 0, sizeof pa2); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
88 memset (pa3, 0, sizeof (pa3)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
89 memset (pa4, 0, sizeof pa4); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
90 memset (pa1, 0, sizeof (struct A *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
91 memset (pa2, 0, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
92 memset (pa3, 0, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
93 memset (pa4, 0, sizeof (__typeof (pa4))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
94
|
|
|
95 memcpy (&a, x, sizeof (&a)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
96 memcpy (pa1, x, sizeof (pa1)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
97 memcpy (pa2, x, sizeof pa2); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
98 memcpy (pa3, x, sizeof (pa3)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
99 memcpy (pa4, x, sizeof pa4); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
100 memcpy (pa1, x, sizeof (struct A *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
101 memcpy (pa2, x, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
102 memcpy (pa3, x, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
103 memcpy (pa4, x, sizeof (__typeof (pa4))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
104
|
|
|
105 memcpy (x, &a, sizeof (&a)); /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
|
|
|
106 memcpy (x, pa1, sizeof (pa1)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
107 memcpy (x, pa2, sizeof pa2); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
108 memcpy (x, pa3, sizeof (pa3)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
109 memcpy (x, pa4, sizeof pa4); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
110 memcpy (x, pa1, sizeof (struct A *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
111 memcpy (x, pa2, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
112 memcpy (x, pa3, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
113 memcpy (x, pa4, sizeof (__typeof (pa4))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
114
|
|
|
115 memmove (&a, x, sizeof (&a)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
116 memmove (pa1, x, sizeof (pa1)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
117 memmove (pa2, x, sizeof pa2); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
118 memmove (pa3, x, sizeof (pa3)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
119 memmove (pa4, x, sizeof pa4); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
120 memmove (pa1, x, sizeof (struct A *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
121 memmove (pa2, x, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
122 memmove (pa3, x, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
123 memmove (pa4, x, sizeof (__typeof (pa4)));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
124
|
|
|
125 memmove (x, &a, sizeof (&a)); /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
|
|
|
126 memmove (x, pa1, sizeof (pa1)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
127 memmove (x, pa2, sizeof pa2); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
128 memmove (x, pa3, sizeof (pa3)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
129 memmove (x, pa4, sizeof pa4); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
130 memmove (x, pa1, sizeof (struct A *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
131 memmove (x, pa2, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
132 memmove (x, pa3, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
133 memmove (x, pa4, sizeof (__typeof (pa4)));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
134
|
|
|
135 z += memcmp (&a, x, sizeof (&a)); /* { dg-warning "call is the same expression as the first source; did you mean to remove the addressof" } */
|
|
|
136 z += memcmp (pa1, x, sizeof (pa1)); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
137 z += memcmp (pa2, x, sizeof pa2); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
138 z += memcmp (pa3, x, sizeof (pa3)); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
139 z += memcmp (pa4, x, sizeof pa4); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
140 z += memcmp (pa1, x, sizeof (struct A *));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the first source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
141 z += memcmp (pa2, x, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the first source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
142 z += memcmp (pa3, x, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the first source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
143
|
|
|
144 z += memcmp (x, &a, sizeof (&a)); /* { dg-warning "call is the same expression as the second source; did you mean to remove the addressof" } */
|
|
|
145 z += memcmp (x, pa1, sizeof (pa1)); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
146 z += memcmp (x, pa2, sizeof pa2); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
147 z += memcmp (x, pa3, sizeof (pa3)); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
148 z += memcmp (x, pa4, sizeof pa4); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
149 z += memcmp (x, pa1, sizeof (struct A *));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
150 z += memcmp (x, pa2, sizeof (PTA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
151 z += memcmp (x, pa3, sizeof (PA)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
152
|
|
|
153 z += memcmp (x, (&a), (sizeof (&a))); /* { dg-warning "call is the same expression as the second source; did you mean to remove the addressof" } */
|
|
|
154 z += memcmp (x, (pa1), (sizeof (pa1))); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
155 z += memcmp (x, (pa2), (sizeof pa2)); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
156 z += memcmp (x, (pa3), (sizeof (pa3))); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
157 z += memcmp (x, (pa4), (sizeof pa4)); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
158 z += memcmp (x, (pa1), (sizeof (struct A *)));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
159 z += memcmp (x, (pa2), (sizeof (PTA))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
160 z += memcmp (x, (pa3), (sizeof (PA))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
161
|
|
|
162 /* These are correct, no warning. */
|
|
|
163 memset (&a, 0, sizeof a);
|
|
|
164 memset (&a, 0, sizeof (a));
|
|
|
165 memset (&a, 0, sizeof (struct A));
|
|
|
166 memset (&a, 0, sizeof (const struct A));
|
|
|
167 memset (&a, 0, sizeof (volatile struct A));
|
|
|
168 memset (&a, 0, sizeof (volatile const struct A));
|
|
|
169 memset (&a, 0, sizeof (TA));
|
|
|
170 memset (&a, 0, sizeof (__typeof (*&a)));
|
|
|
171 memset (pa1, 0, sizeof (*pa1));
|
|
|
172 memset (pa2, 0, sizeof (*pa3));
|
|
|
173 memset (pa3, 0, sizeof (__typeof (*pa3)));
|
|
|
174 /* These are probably broken, but obfuscated, no warning. */
|
|
|
175 memset ((void *) &a, 0, sizeof (&a));
|
|
|
176 memset ((char *) &a, 0, sizeof (&a));
|
|
|
177 memset (&a, 0, sizeof (&a) + 0);
|
|
|
178 memset (&a, 0, 0 + sizeof (&a));
|
|
|
179
|
|
|
180 /* These are correct, no warning. */
|
|
|
181 memcpy (&a, x, sizeof a);
|
|
|
182 memcpy (&a, x, sizeof (a));
|
|
|
183 memcpy (&a, x, sizeof (struct A));
|
|
|
184 memcpy (&a, x, sizeof (const struct A));
|
|
|
185 memcpy (&a, x, sizeof (volatile struct A));
|
|
|
186 memcpy (&a, x, sizeof (volatile const struct A));
|
|
|
187 memcpy (&a, x, sizeof (TA));
|
|
|
188 memcpy (&a, x, sizeof (__typeof (*&a)));
|
|
|
189 memcpy (pa1, x, sizeof (*pa1));
|
|
|
190 memcpy (pa2, x, sizeof (*pa3));
|
|
|
191 memcpy (pa3, x, sizeof (__typeof (*pa3)));
|
|
|
192 /* These are probably broken, but obfuscated, no warning. */
|
|
|
193 memcpy ((void *) &a, x, sizeof (&a));
|
|
|
194 memcpy ((char *) &a, x, sizeof (&a));
|
|
|
195 memcpy (&a, x, sizeof (&a) + 0);
|
|
|
196 memcpy (&a, x, 0 + sizeof (&a));
|
|
|
197
|
|
|
198 /* These are correct, no warning. */
|
|
|
199 memcpy (x, &a, sizeof a);
|
|
|
200 memcpy (x, &a, sizeof (a));
|
|
|
201 memcpy (x, &a, sizeof (struct A));
|
|
|
202 memcpy (x, &a, sizeof (const struct A));
|
|
|
203 memcpy (x, &a, sizeof (volatile struct A));
|
|
|
204 memcpy (x, &a, sizeof (volatile const struct A));
|
|
|
205 memcpy (x, &a, sizeof (TA));
|
|
|
206 memcpy (x, &a, sizeof (__typeof (*&a)));
|
|
|
207 memcpy (x, pa1, sizeof (*pa1));
|
|
|
208 memcpy (x, pa2, sizeof (*pa3));
|
|
|
209 memcpy (x, pa3, sizeof (__typeof (*pa3)));
|
|
|
210 /* These are probably broken, but obfuscated, no warning. */
|
|
|
211 memcpy (x, (void *) &a, sizeof (&a));
|
|
|
212 memcpy (x, (char *) &a, sizeof (&a));
|
|
|
213 memcpy (x, &a, sizeof (&a) + 0);
|
|
|
214 memcpy (x, &a, 0 + sizeof (&a));
|
|
|
215
|
|
|
216 /* These are correct, no warning. */
|
|
|
217 memmove (&a, x, sizeof a);
|
|
|
218 memmove (&a, x, sizeof (a));
|
|
|
219 memmove (&a, x, sizeof (struct A));
|
|
|
220 memmove (&a, x, sizeof (const struct A));
|
|
|
221 memmove (&a, x, sizeof (volatile struct A));
|
|
|
222 memmove (&a, x, sizeof (volatile const struct A));
|
|
|
223 memmove (&a, x, sizeof (TA));
|
|
|
224 memmove (&a, x, sizeof (__typeof (*&a)));
|
|
|
225 memmove (pa1, x, sizeof (*pa1));
|
|
|
226 memmove (pa2, x, sizeof (*pa3));
|
|
|
227 memmove (pa3, x, sizeof (__typeof (*pa3)));
|
|
|
228 /* These are probably broken, but obfuscated, no warning. */
|
|
|
229 memmove ((void *) &a, x, sizeof (&a));
|
|
|
230 memmove ((char *) &a, x, sizeof (&a));
|
|
|
231 memmove (&a, x, sizeof (&a) + 0);
|
|
|
232 memmove (&a, x, 0 + sizeof (&a));
|
|
|
233
|
|
|
234 /* These are correct, no warning. */
|
|
|
235 memmove (x, &a, sizeof a);
|
|
|
236 memmove (x, &a, sizeof (a));
|
|
|
237 memmove (x, &a, sizeof (struct A));
|
|
|
238 memmove (x, &a, sizeof (const struct A));
|
|
|
239 memmove (x, &a, sizeof (volatile struct A));
|
|
|
240 memmove (x, &a, sizeof (volatile const struct A));
|
|
|
241 memmove (x, &a, sizeof (TA));
|
|
|
242 memmove (x, &a, sizeof (__typeof (*&a)));
|
|
|
243 memmove (x, pa1, sizeof (*pa1));
|
|
|
244 memmove (x, pa2, sizeof (*pa3));
|
|
|
245 memmove (x, pa3, sizeof (__typeof (*pa3)));
|
|
|
246 /* These are probably broken, but obfuscated, no warning. */
|
|
|
247 memmove (x, (void *) &a, sizeof (&a));
|
|
|
248 memmove (x, (char *) &a, sizeof (&a));
|
|
|
249 memmove (x, &a, sizeof (&a) + 0);
|
|
|
250 memmove (x, &a, 0 + sizeof (&a));
|
|
|
251
|
|
|
252 /* These are correct, no warning. */
|
|
|
253 z += memcmp (&a, x, sizeof a);
|
|
|
254 z += memcmp (&a, x, sizeof (a));
|
|
|
255 z += memcmp (&a, x, sizeof (struct A));
|
|
|
256 z += memcmp (&a, x, sizeof (const struct A));
|
|
|
257 z += memcmp (&a, x, sizeof (volatile struct A));
|
|
|
258 z += memcmp (&a, x, sizeof (volatile const struct A));
|
|
|
259 z += memcmp (&a, x, sizeof (TA));
|
|
|
260 z += memcmp (&a, x, sizeof (__typeof (*&a)));
|
|
|
261 z += memcmp (pa1, x, sizeof (*pa1));
|
|
|
262 z += memcmp (pa2, x, sizeof (*pa3));
|
|
|
263 z += memcmp (pa3, x, sizeof (__typeof (*pa3)));
|
|
|
264 /* These are probably broken, but obfuscated, no warning. */
|
|
|
265 z += memcmp ((void *) &a, x, sizeof (&a));
|
|
|
266 z += memcmp ((char *) &a, x, sizeof (&a));
|
|
|
267 z += memcmp (&a, x, sizeof (&a) + 0);
|
|
|
268 z += memcmp (&a, x, 0 + sizeof (&a));
|
|
|
269
|
|
|
270 /* These are correct, no warning. */
|
|
|
271 z += memcmp (x, &a, sizeof a);
|
|
|
272 z += memcmp (x, &a, sizeof (a));
|
|
|
273 z += memcmp (x, &a, sizeof (struct A));
|
|
|
274 z += memcmp (x, &a, sizeof (const struct A));
|
|
|
275 z += memcmp (x, &a, sizeof (volatile struct A));
|
|
|
276 z += memcmp (x, &a, sizeof (volatile const struct A));
|
|
|
277 z += memcmp (x, &a, sizeof (TA));
|
|
|
278 z += memcmp (x, &a, sizeof (__typeof (*&a)));
|
|
|
279 z += memcmp (x, pa1, sizeof (*pa1));
|
|
|
280 z += memcmp (x, pa2, sizeof (*pa3));
|
|
|
281 z += memcmp (x, pa3, sizeof (__typeof (*pa3)));
|
|
|
282 /* These are probably broken, but obfuscated, no warning. */
|
|
|
283 z += memcmp (x, (void *) &a, sizeof (&a));
|
|
|
284 z += memcmp (x, (char *) &a, sizeof (&a));
|
|
|
285 z += memcmp (x, &a, sizeof (&a) + 0);
|
|
|
286 z += memcmp (x, &a, 0 + sizeof (&a));
|
|
|
287
|
|
|
288 return z;
|
|
|
289 }
|
|
|
290
|
|
|
291 int
|
|
|
292 f2 (void *x, int z)
|
|
|
293 {
|
|
|
294 struct B b, *pb1 = &b;
|
|
|
295 TB *pb2 = &b;
|
|
|
296 PB pb3 = &b;
|
|
|
297 PTB pb4 = &b;
|
|
|
298 memset (&b, 0, sizeof (&b)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
299 memset (pb1, 0, sizeof (pb1)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
300 memset (pb2, 0, sizeof pb2); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
301 memset (pb3, 0, sizeof (pb3)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
302 memset (pb4, 0, sizeof pb4); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
303 memset (pb1, 0, sizeof (struct B *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
304 memset (pb2, 0, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
305 memset (pb3, 0, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
306 memset (pb4, 0, sizeof (__typeof (pb4))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
307
|
|
|
308 memcpy (&b, x, sizeof (&b)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
309 memcpy (pb1, x, sizeof (pb1)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
310 memcpy (pb2, x, sizeof pb2); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
311 memcpy (pb3, x, sizeof (pb3)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
312 memcpy (pb4, x, sizeof pb4); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
313 memcpy (pb1, x, sizeof (struct B *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
314 memcpy (pb2, x, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
315 memcpy (pb3, x, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
316 memcpy (pb4, x, sizeof (__typeof (pb4))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
317
|
|
|
318 memcpy (x, &b, sizeof (&b)); /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
|
|
|
319 memcpy (x, pb1, sizeof (pb1)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
320 memcpy (x, pb2, sizeof pb2); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
321 memcpy (x, pb3, sizeof (pb3)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
322 memcpy (x, pb4, sizeof pb4); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
323 memcpy (x, pb1, sizeof (struct B *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
324 memcpy (x, pb2, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
325 memcpy (x, pb3, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
326 memcpy (x, pb4, sizeof (__typeof (pb4))); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
327
|
|
|
328 memmove (&b, x, sizeof (&b)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
329 memmove (pb1, x, sizeof (pb1)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
330 memmove (pb2, x, sizeof pb2); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
331 memmove (pb3, x, sizeof (pb3)); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
332 memmove (pb4, x, sizeof pb4); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
333 memmove (pb1, x, sizeof (struct B *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
334 memmove (pb2, x, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
335 memmove (pb3, x, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
336 memmove (pb4, x, sizeof (__typeof (pb4)));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the destination; expected \[^\n\r\]* or an explicit length" } */
|
|
|
337
|
|
|
338 memmove (x, &b, sizeof (&b)); /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
|
|
|
339 memmove (x, pb1, sizeof (pb1)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
340 memmove (x, pb2, sizeof pb2); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
341 memmove (x, pb3, sizeof (pb3)); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
342 memmove (x, pb4, sizeof pb4); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
343 memmove (x, pb1, sizeof (struct B *)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
344 memmove (x, pb2, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
345 memmove (x, pb3, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
346 memmove (x, pb4, sizeof (__typeof (pb4)));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
347
|
|
|
348 z += memcmp (&b, x, sizeof (&b)); /* { dg-warning "call is the same expression as the first source; did you mean to remove the addressof" } */
|
|
|
349 z += memcmp (pb1, x, sizeof (pb1)); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
350 z += memcmp (pb2, x, sizeof pb2); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
351 z += memcmp (pb3, x, sizeof (pb3)); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
352 z += memcmp (pb4, x, sizeof pb4); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
353 z += memcmp (pb1, x, sizeof (struct B *));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the first source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
354 z += memcmp (pb2, x, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the first source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
355 z += memcmp (pb3, x, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the first source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
356
|
|
|
357 z += memcmp (x, &b, sizeof (&b)); /* { dg-warning "call is the same expression as the second source; did you mean to remove the addressof" } */
|
|
|
358 z += memcmp (x, pb1, sizeof (pb1)); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
359 z += memcmp (x, pb2, sizeof pb2); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
360 z += memcmp (x, pb3, sizeof (pb3)); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
361 z += memcmp (x, pb4, sizeof pb4); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
362 z += memcmp (x, pb1, sizeof (struct B *));/* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
363 z += memcmp (x, pb2, sizeof (PTB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
364 z += memcmp (x, pb3, sizeof (PB)); /* { dg-warning "call is the same pointer type \[^\n\r\]* as the second source; expected \[^\n\r\]* or an explicit length" } */
|
|
|
365
|
|
|
366 /* These are correct, no warning. */
|
|
|
367 memset (&b, 0, sizeof b);
|
|
|
368 memset (&b, 0, sizeof (b));
|
|
|
369 memset (&b, 0, sizeof (struct B));
|
|
|
370 memset (&b, 0, sizeof (const struct B));
|
|
|
371 memset (&b, 0, sizeof (volatile struct B));
|
|
|
372 memset (&b, 0, sizeof (volatile const struct B));
|
|
|
373 memset (&b, 0, sizeof (TB));
|
|
|
374 memset (&b, 0, sizeof (__typeof (*&b)));
|
|
|
375 memset (pb1, 0, sizeof (*pb1));
|
|
|
376 memset (pb2, 0, sizeof (*pb3));
|
|
|
377 memset (pb3, 0, sizeof (__typeof (*pb3)));
|
|
|
378 /* These are probably broken, but obfuscated, no warning. */
|
|
|
379 memset ((void *) &b, 0, sizeof (&b));
|
|
|
380 memset ((char *) &b, 0, sizeof (&b));
|
|
|
381 memset (&b, 0, sizeof (&b) + 0);
|
|
|
382 memset (&b, 0, 0 + sizeof (&b));
|
|
|
383
|
|
|
384 /* These are correct, no warning. */
|
|
|
385 memcpy (&b, x, sizeof b);
|
|
|
386 memcpy (&b, x, sizeof (b));
|
|
|
387 memcpy (&b, x, sizeof (struct B));
|
|
|
388 memcpy (&b, x, sizeof (const struct B));
|
|
|
389 memcpy (&b, x, sizeof (volatile struct B));
|
|
|
390 memcpy (&b, x, sizeof (volatile const struct B));
|
|
|
391 memcpy (&b, x, sizeof (TB));
|
|
|
392 memcpy (&b, x, sizeof (__typeof (*&b)));
|
|
|
393 memcpy (pb1, x, sizeof (*pb1));
|
|
|
394 memcpy (pb2, x, sizeof (*pb3));
|
|
|
395 memcpy (pb3, x, sizeof (__typeof (*pb3)));
|
|
|
396 /* These are probably broken, but obfuscated, no warning. */
|
|
|
397 memcpy ((void *) &b, x, sizeof (&b));
|
|
|
398 memcpy ((char *) &b, x, sizeof (&b));
|
|
|
399 memcpy (&b, x, sizeof (&b) + 0);
|
|
|
400 memcpy (&b, x, 0 + sizeof (&b));
|
|
|
401
|
|
|
402 /* These are correct, no warning. */
|
|
|
403 memcpy (x, &b, sizeof b);
|
|
|
404 memcpy (x, &b, sizeof (b));
|
|
|
405 memcpy (x, &b, sizeof (struct B));
|
|
|
406 memcpy (x, &b, sizeof (const struct B));
|
|
|
407 memcpy (x, &b, sizeof (volatile struct B));
|
|
|
408 memcpy (x, &b, sizeof (volatile const struct B));
|
|
|
409 memcpy (x, &b, sizeof (TB));
|
|
|
410 memcpy (x, &b, sizeof (__typeof (*&b)));
|
|
|
411 memcpy (x, pb1, sizeof (*pb1));
|
|
|
412 memcpy (x, pb2, sizeof (*pb3));
|
|
|
413 memcpy (x, pb3, sizeof (__typeof (*pb3)));
|
|
|
414 /* These are probably broken, but obfuscated, no warning. */
|
|
|
415 memcpy (x, (void *) &b, sizeof (&b));
|
|
|
416 memcpy (x, (char *) &b, sizeof (&b));
|
|
|
417 memcpy (x, &b, sizeof (&b) + 0);
|
|
|
418 memcpy (x, &b, 0 + sizeof (&b));
|
|
|
419
|
|
|
420 /* These are correct, no warning. */
|
|
|
421 memmove (&b, x, sizeof b);
|
|
|
422 memmove (&b, x, sizeof (b));
|
|
|
423 memmove (&b, x, sizeof (struct B));
|
|
|
424 memmove (&b, x, sizeof (const struct B));
|
|
|
425 memmove (&b, x, sizeof (volatile struct B));
|
|
|
426 memmove (&b, x, sizeof (volatile const struct B));
|
|
|
427 memmove (&b, x, sizeof (TB));
|
|
|
428 memmove (&b, x, sizeof (__typeof (*&b)));
|
|
|
429 memmove (pb1, x, sizeof (*pb1));
|
|
|
430 memmove (pb2, x, sizeof (*pb3));
|
|
|
431 memmove (pb3, x, sizeof (__typeof (*pb3)));
|
|
|
432 /* These are probably broken, but obfuscated, no warning. */
|
|
|
433 memmove ((void *) &b, x, sizeof (&b));
|
|
|
434 memmove ((char *) &b, x, sizeof (&b));
|
|
|
435 memmove (&b, x, sizeof (&b) + 0);
|
|
|
436 memmove (&b, x, 0 + sizeof (&b));
|
|
|
437
|
|
|
438 /* These are correct, no warning. */
|
|
|
439 memmove (x, &b, sizeof b);
|
|
|
440 memmove (x, &b, sizeof (b));
|
|
|
441 memmove (x, &b, sizeof (struct B));
|
|
|
442 memmove (x, &b, sizeof (const struct B));
|
|
|
443 memmove (x, &b, sizeof (volatile struct B));
|
|
|
444 memmove (x, &b, sizeof (volatile const struct B));
|
|
|
445 memmove (x, &b, sizeof (TB));
|
|
|
446 memmove (x, &b, sizeof (__typeof (*&b)));
|
|
|
447 memmove (x, pb1, sizeof (*pb1));
|
|
|
448 memmove (x, pb2, sizeof (*pb3));
|
|
|
449 memmove (x, pb3, sizeof (__typeof (*pb3)));
|
|
|
450 /* These are probably broken, but obfuscated, no warning. */
|
|
|
451 memmove (x, (void *) &b, sizeof (&b));
|
|
|
452 memmove (x, (char *) &b, sizeof (&b));
|
|
|
453 memmove (x, &b, sizeof (&b) + 0);
|
|
|
454 memmove (x, &b, 0 + sizeof (&b));
|
|
|
455
|
|
|
456 /* These are correct, no warning. */
|
|
|
457 z += memcmp (&b, x, sizeof b);
|
|
|
458 z += memcmp (&b, x, sizeof (b));
|
|
|
459 z += memcmp (&b, x, sizeof (struct B));
|
|
|
460 z += memcmp (&b, x, sizeof (const struct B));
|
|
|
461 z += memcmp (&b, x, sizeof (volatile struct B));
|
|
|
462 z += memcmp (&b, x, sizeof (volatile const struct B));
|
|
|
463 z += memcmp (&b, x, sizeof (TB));
|
|
|
464 z += memcmp (&b, x, sizeof (__typeof (*&b)));
|
|
|
465 z += memcmp (pb1, x, sizeof (*pb1));
|
|
|
466 z += memcmp (pb2, x, sizeof (*pb3));
|
|
|
467 z += memcmp (pb3, x, sizeof (__typeof (*pb3)));
|
|
|
468 /* These are probably broken, but obfuscated, no warning. */
|
|
|
469 z += memcmp ((void *) &b, x, sizeof (&b));
|
|
|
470 z += memcmp ((char *) &b, x, sizeof (&b));
|
|
|
471 z += memcmp (&b, x, sizeof (&b) + 0);
|
|
|
472 z += memcmp (&b, x, 0 + sizeof (&b));
|
|
|
473
|
|
|
474 /* These are correct, no warning. */
|
|
|
475 z += memcmp (x, &b, sizeof b);
|
|
|
476 z += memcmp (x, &b, sizeof (b));
|
|
|
477 z += memcmp (x, &b, sizeof (struct B));
|
|
|
478 z += memcmp (x, &b, sizeof (const struct B));
|
|
|
479 z += memcmp (x, &b, sizeof (volatile struct B));
|
|
|
480 z += memcmp (x, &b, sizeof (volatile const struct B));
|
|
|
481 z += memcmp (x, &b, sizeof (TB));
|
|
|
482 z += memcmp (x, &b, sizeof (__typeof (*&b)));
|
|
|
483 z += memcmp (x, pb1, sizeof (*pb1));
|
|
|
484 z += memcmp (x, pb2, sizeof (*pb3));
|
|
|
485 z += memcmp (x, pb3, sizeof (__typeof (*pb3)));
|
|
|
486 /* These are probably broken, but obfuscated, no warning. */
|
|
|
487 z += memcmp (x, (void *) &b, sizeof (&b));
|
|
|
488 z += memcmp (x, (char *) &b, sizeof (&b));
|
|
|
489 z += memcmp (x, &b, sizeof (&b) + 0);
|
|
|
490 z += memcmp (x, &b, 0 + sizeof (&b));
|
|
|
491
|
|
|
492 return z;
|
|
|
493 }
|
|
|
494
|
|
|
495 int
|
|
|
496 f3 (void *x, char *y, int z, X w)
|
|
|
497 {
|
|
|
498 unsigned char *y1 = (unsigned char *) __builtin_alloca (z + 16);
|
|
|
499 char buf1[7];
|
|
|
500 signed char buf2[z + 32];
|
|
|
501 long buf3[17];
|
|
|
502 int *buf4[9];
|
|
|
503 signed char *y2 = buf2;
|
|
|
504 char c;
|
|
|
505 char *y3;
|
|
|
506 memset (y, 0, sizeof (y)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
507 memset (y1, 0, sizeof (y1)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
508 memset (y2, 0, sizeof (y2)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
509 memset (&c, 0, sizeof (&c)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
510 memset (w, 0, sizeof w); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
511
|
|
|
512 memcpy (y, x, sizeof (y)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
513 memcpy (y1, x, sizeof (y1)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
514 memcpy (y2, x, sizeof (y2)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
515 memcpy (&c, x, sizeof (&c)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
516 memcpy (w, x, sizeof w); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
517
|
|
|
518 memcpy (x, y, sizeof (y)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
519 memcpy (x, y1, sizeof (y1)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
520 memcpy (x, y2, sizeof (y2)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
521 memcpy (x, &c, sizeof (&c)); /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
|
|
|
522 memcpy (x, w, sizeof w); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
523
|
|
|
524 memmove (y, x, sizeof (y)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
525 memmove (y1, x, sizeof (y1)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
526 memmove (y2, x, sizeof (y2)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
527 memmove (&c, x, sizeof (&c)); /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
|
|
|
528 memmove (w, x, sizeof w); /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
|
|
|
529
|
|
|
530 memmove (x, y, sizeof (y)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
531 memmove (x, y1, sizeof (y1)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
532 memmove (x, y2, sizeof (y2)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
533 memmove (x, &c, sizeof (&c)); /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
|
|
|
534 memmove (x, w, sizeof w); /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
|
|
|
535
|
|
|
536 z += memcmp (y, x, sizeof (y)); /* { dg-warning "call is the same expression as the first source; did you mean to provide an explicit length" } */
|
|
|
537 z += memcmp (y1, x, sizeof (y1)); /* { dg-warning "call is the same expression as the first source; did you mean to provide an explicit length" } */
|
|
|
538 z += memcmp (y2, x, sizeof (y2)); /* { dg-warning "call is the same expression as the first source; did you mean to provide an explicit length" } */
|
|
|
539 z += memcmp (&c, x, sizeof (&c)); /* { dg-warning "call is the same expression as the first source; did you mean to remove the addressof" } */
|
|
|
540 z += memcmp (w, x, sizeof w); /* { dg-warning "call is the same expression as the first source; did you mean to dereference it" } */
|
|
|
541
|
|
|
542 z += memcmp (x, y, sizeof (y)); /* { dg-warning "call is the same expression as the second source; did you mean to provide an explicit length" } */
|
|
|
543 z += memcmp (x, y1, sizeof (y1)); /* { dg-warning "call is the same expression as the second source; did you mean to provide an explicit length" } */
|
|
|
544 z += memcmp (x, y2, sizeof (y2)); /* { dg-warning "call is the same expression as the second source; did you mean to provide an explicit length" } */
|
|
|
545 z += memcmp (x, &c, sizeof (&c)); /* { dg-warning "call is the same expression as the second source; did you mean to remove the addressof" } */
|
|
|
546 z += memcmp (x, w, sizeof w); /* { dg-warning "call is the same expression as the second source; did you mean to dereference it" } */
|
|
|
547
|
|
|
548 /* These are correct, no warning. */
|
|
|
549 memset (y, 0, sizeof (*y));
|
|
|
550 memset (y1, 0, sizeof (*y2));
|
|
|
551 memset (buf1, 0, sizeof buf1);
|
|
|
552 memset (buf3, 0, sizeof (buf3));
|
|
|
553 memset (&buf3[0], 0, sizeof (buf3));
|
|
|
554 memset (&buf4[0], 0, sizeof (buf4));
|
|
|
555 memset (w, 0, sizeof (X));
|
|
|
556 /* These are probably broken, but obfuscated, no warning. */
|
|
|
557 memset ((void *) y, 0, sizeof (y));
|
|
|
558 memset ((char *) y1, 0, sizeof (y2));
|
|
|
559 memset (y, 0, sizeof (y) + 0);
|
|
|
560 memset (y1, 0, 0 + sizeof (y2));
|
|
|
561 memset ((void *) &c, 0, sizeof (&c));
|
|
|
562 memset ((signed char *) &c, 0, sizeof (&c));
|
|
|
563 memset (&c, 0, sizeof (&c) + 0);
|
|
|
564 memset (&c, 0, 0 + sizeof (&c));
|
|
|
565
|
|
|
566 /* These are correct, no warning. */
|
|
|
567 memcpy (y, x, sizeof (*y));
|
|
|
568 memcpy (y1, x, sizeof (*y2));
|
|
|
569 memcpy (buf1, x, sizeof buf1);
|
|
|
570 memcpy (buf3, x, sizeof (buf3));
|
|
|
571 memcpy (&buf3[0], x, sizeof (buf3));
|
|
|
572 memcpy (&buf4[0], x, sizeof (buf4));
|
|
|
573 memcpy (&y3, y, sizeof (y3));
|
|
|
574 memcpy ((char *) &y3, y, sizeof (y3));
|
|
|
575 memcpy (w, x, sizeof (X));
|
|
|
576 /* These are probably broken, but obfuscated, no warning. */
|
|
|
577 memcpy ((void *) y, x, sizeof (y));
|
|
|
578 memcpy ((char *) y1, x, sizeof (y2));
|
|
|
579 memcpy (y, x, sizeof (y) + 0);
|
|
|
580 memcpy (y1, x, 0 + sizeof (y2));
|
|
|
581 memcpy ((void *) &c, x, sizeof (&c));
|
|
|
582 memcpy ((signed char *) &c, x, sizeof (&c));
|
|
|
583 memcpy (&c, x, sizeof (&c) + 0);
|
|
|
584 memcpy (&c, x, 0 + sizeof (&c));
|
|
|
585
|
|
|
586 /* These are correct, no warning. */
|
|
|
587 memcpy (x, y, sizeof (*y));
|
|
|
588 memcpy (x, y1, sizeof (*y2));
|
|
|
589 memcpy (x, buf1, sizeof buf1);
|
|
|
590 memcpy (x, buf3, sizeof (buf3));
|
|
|
591 memcpy (x, &buf3[0], sizeof (buf3));
|
|
|
592 memcpy (x, &buf4[0], sizeof (buf4));
|
|
|
593 memcpy (y, &y3, sizeof (y3));
|
|
|
594 memcpy (y, (char *) &y3, sizeof (y3));
|
|
|
595 memcpy (x, w, sizeof (X));
|
|
|
596 /* These are probably broken, but obfuscated, no warning. */
|
|
|
597 memcpy (x, (void *) y, sizeof (y));
|
|
|
598 memcpy (x, (char *) y1, sizeof (y2));
|
|
|
599 memcpy (x, y, sizeof (y) + 0);
|
|
|
600 memcpy (x, y1, 0 + sizeof (y2));
|
|
|
601 memcpy (x, (void *) &c, sizeof (&c));
|
|
|
602 memcpy (x, (signed char *) &c, sizeof (&c));
|
|
|
603 memcpy (x, &c, sizeof (&c) + 0);
|
|
|
604 memcpy (x, &c, 0 + sizeof (&c));
|
|
|
605
|
|
|
606 /* These are correct, no warning. */
|
|
|
607 memmove (y, x, sizeof (*y));
|
|
|
608 memmove (y1, x, sizeof (*y2));
|
|
|
609 memmove (buf1, x, sizeof buf1);
|
|
|
610 memmove (buf3, x, sizeof (buf3));
|
|
|
611 memmove (&buf3[0], x, sizeof (buf3));
|
|
|
612 memmove (&buf4[0], x, sizeof (buf4));
|
|
|
613 memmove (&y3, y, sizeof (y3));
|
|
|
614 memmove ((char *) &y3, y, sizeof (y3));
|
|
|
615 memmove (w, x, sizeof (X));
|
|
|
616 /* These are probably broken, but obfuscated, no warning. */
|
|
|
617 memmove ((void *) y, x, sizeof (y));
|
|
|
618 memmove ((char *) y1, x, sizeof (y2));
|
|
|
619 memmove (y, x, sizeof (y) + 0);
|
|
|
620 memmove (y1, x, 0 + sizeof (y2));
|
|
|
621 memmove ((void *) &c, x, sizeof (&c));
|
|
|
622 memmove ((signed char *) &c, x, sizeof (&c));
|
|
|
623 memmove (&c, x, sizeof (&c) + 0);
|
|
|
624 memmove (&c, x, 0 + sizeof (&c));
|
|
|
625
|
|
|
626 /* These are correct, no warning. */
|
|
|
627 memmove (x, y, sizeof (*y));
|
|
|
628 memmove (x, y1, sizeof (*y2));
|
|
|
629 memmove (x, buf1, sizeof buf1);
|
|
|
630 memmove (x, buf3, sizeof (buf3));
|
|
|
631 memmove (x, &buf3[0], sizeof (buf3));
|
|
|
632 memmove (x, &buf4[0], sizeof (buf4));
|
|
|
633 memmove (y, &y3, sizeof (y3));
|
|
|
634 memmove (y, (char *) &y3, sizeof (y3));
|
|
|
635 memmove (x, w, sizeof (X));
|
|
|
636 /* These are probably broken, but obfuscated, no warning. */
|
|
|
637 memmove (x, (void *) y, sizeof (y));
|
|
|
638 memmove (x, (char *) y1, sizeof (y2));
|
|
|
639 memmove (x, y, sizeof (y) + 0);
|
|
|
640 memmove (x, y1, 0 + sizeof (y2));
|
|
|
641 memmove (x, (void *) &c, sizeof (&c));
|
|
|
642 memmove (x, (signed char *) &c, sizeof (&c));
|
|
|
643 memmove (x, &c, sizeof (&c) + 0);
|
|
|
644 memmove (x, &c, 0 + sizeof (&c));
|
|
|
645
|
|
|
646 /* These are correct, no warning. */
|
|
|
647 z += memcmp (y, x, sizeof (*y));
|
|
|
648 z += memcmp (y1, x, sizeof (*y2));
|
|
|
649 z += memcmp (buf1, x, sizeof buf1);
|
|
|
650 z += memcmp (buf3, x, sizeof (buf3));
|
|
|
651 z += memcmp (&buf3[0], x, sizeof (buf3));
|
|
|
652 z += memcmp (&buf4[0], x, sizeof (buf4));
|
|
|
653 z += memcmp (&y3, y, sizeof (y3));
|
|
|
654 z += memcmp ((char *) &y3, y, sizeof (y3));
|
|
|
655 z += memcmp (w, x, sizeof (X));
|
|
|
656 /* These are probably broken, but obfuscated, no warning. */
|
|
|
657 z += memcmp ((void *) y, x, sizeof (y));
|
|
|
658 z += memcmp ((char *) y1, x, sizeof (y2));
|
|
|
659 z += memcmp (y, x, sizeof (y) + 0);
|
|
|
660 z += memcmp (y1, x, 0 + sizeof (y2));
|
|
|
661 z += memcmp ((void *) &c, x, sizeof (&c));
|
|
|
662 z += memcmp ((signed char *) &c, x, sizeof (&c));
|
|
|
663 z += memcmp (&c, x, sizeof (&c) + 0);
|
|
|
664 z += memcmp (&c, x, 0 + sizeof (&c));
|
|
|
665
|
|
|
666 /* These are correct, no warning. */
|
|
|
667 z += memcmp (x, y, sizeof (*y));
|
|
|
668 z += memcmp (x, y1, sizeof (*y2));
|
|
|
669 z += memcmp (x, buf1, sizeof buf1);
|
|
|
670 z += memcmp (x, buf3, sizeof (buf3));
|
|
|
671 z += memcmp (x, &buf3[0], sizeof (buf3));
|
|
|
672 z += memcmp (x, &buf4[0], sizeof (buf4));
|
|
|
673 z += memcmp (y, &y3, sizeof (y3));
|
|
|
674 z += memcmp (y, (char *) &y3, sizeof (y3));
|
|
|
675 z += memcmp (x, w, sizeof (X));
|
|
|
676 /* These are probably broken, but obfuscated, no warning. */
|
|
|
677 z += memcmp (x, (void *) y, sizeof (y));
|
|
|
678 z += memcmp (x, (char *) y1, sizeof (y2));
|
|
|
679 z += memcmp (x, y, sizeof (y) + 0);
|
|
|
680 z += memcmp (x, y1, 0 + sizeof (y2));
|
|
|
681 z += memcmp (x, (void *) &c, sizeof (&c));
|
|
|
682 z += memcmp (x, (signed char *) &c, sizeof (&c));
|
|
|
683 z += memcmp (x, &c, sizeof (&c) + 0);
|
|
|
684 z += memcmp (x, &c, 0 + sizeof (&c));
|
|
|
685
|
|
|
686 return z;
|
|
|
687 }
|
|
|
688
|
|
|
689 int
|
|
|
690 f4 (char *x, char **y, int z, char w[64])
|
|
|
691 {
|
|
|
692 const char *s1 = "foobarbaz";
|
|
|
693 const char *s2 = "abcde12345678";
|
|
|
694 strncpy (x, s1, sizeof (s1)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
695 strncat (x, s2, sizeof (s2)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
696 stpncpy (x, s1, sizeof (s1)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
697 y[0] = strndup (s1, sizeof (s1)); /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
|
|
|
698 z += strncmp (s1, s2, sizeof (s1)); /* { dg-warning "call is the same expression as the first source; did you mean to provide an explicit length" } */
|
|
|
699 z += strncmp (s1, s2, sizeof (s2)); /* { dg-warning "call is the same expression as the second source; did you mean to provide an explicit length" } */
|
|
|
700 z += strncasecmp (s1, s2, sizeof (s1)); /* { dg-warning "call is the same expression as the first source; did you mean to provide an explicit length" } */
|
|
|
701 z += strncasecmp (s1, s2, sizeof (s2)); /* { dg-warning "call is the same expression as the second source; did you mean to provide an explicit length" } */
|
|
|
702
|
|
|
703 strncpy (w, s1, sizeof (w)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
704 strncat (w, s2, sizeof (w)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
705 stpncpy (w, s1, sizeof (w)); /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
|
|
|
706
|
|
131
|
707 /* These are pointless when the destination is large enough, and
|
|
|
708 cause overflow otherwise. If the copies are guaranteed to be
|
|
|
709 safe the calls might as well be replaced by strcat(), strcpy(),
|
|
|
710 or memcpy(). */
|
|
111
|
711 const char s3[] = "foobarbaz";
|
|
|
712 const char s4[] = "abcde12345678";
|
|
131
|
713 strncpy (x, s3, sizeof (s3)); /* { dg-warning "call is the same expression as the source; did you mean to use the size of the destination?" } */
|
|
|
714 strncat (x, s4, sizeof (s4)); /* { dg-warning "call is the same expression as the source; did you mean to use the size of the destination?" } */
|
|
|
715 stpncpy (x, s3, sizeof (s3)); /* { dg-warning "call is the same expression as the source; did you mean to use the size of the destination?" } */
|
|
|
716
|
|
|
717 /* These are correct, no warning. */
|
|
111
|
718 y[1] = strndup (s3, sizeof (s3));
|
|
|
719 z += strncmp (s3, s4, sizeof (s3));
|
|
|
720 z += strncmp (s3, s4, sizeof (s4));
|
|
|
721 z += strncasecmp (s3, s4, sizeof (s3));
|
|
|
722 z += strncasecmp (s3, s4, sizeof (s4));
|
|
|
723
|
|
|
724 return z;
|
|
|
725 }
|
|
|
726
|
|
|
727 /* { dg-prune-output "\[\n\r\]*writing\[\n\r\]*" } */
|
