1 /* Test -Wsizeof-pointer-memaccess warnings.  */
2 /* { dg-do compile } */
3 /* { dg-options "-Wall -Wno-array-bounds -Wno-sizeof-array-argument -Wno-stringop-overflow -Wno-stringop-truncation" } */
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 *
memset(void * dest,int c,size_t len)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 *
memcpy(void * __restrict dest,const void * __restrict src,size_t len)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 *
memmove(void * dest,const void * src,size_t len)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 *
strncpy(char * __restrict dest,const char * __restrict src,size_t len)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 *
strncat(char * dest,const char * src,size_t len)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 *
stpncpy(char * __restrict dest,const char * __restrict src,size_t len)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
f1(void * x,int z)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
f2(void * x,int z)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
f3(void * x,char * y,int z,X w)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
f4(char * x,char ** y,int z,char w[64])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 
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().  */
711   const char s3[] = "foobarbaz";
712   const char s4[] = "abcde12345678";
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.  */
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\]*" } */
728