1 /* Test -Wsizeof-pointer-memaccess warnings.  */
2 /* { dg-do compile } */
3 /* { dg-options "-Wall -O2 -Wno-array-bounds -Wno-sizeof-array-argument -Wno-stringop-truncation -ftrack-macro-expansion=0" } */
4 /* { dg-options "-Wall -O2 -Wno-array-bounds -Wno-sizeof-array-argument -Wno-stringop-truncation -Wno-c++-compat -ftrack-macro-expansion=0" {target c} } */
5 /* { dg-require-effective-target alloca } */
6 
7 #define bos(ptr) __builtin_object_size (ptr, 1)
8 #define bos0(ptr) __builtin_object_size (ptr, 0)
9 
10 #define memset(dst, val, sz) __builtin___memset_chk (dst, val, sz, bos (dst))
11 #define memcpy(dst, src, sz) __builtin___memcpy_chk (dst, src, sz, bos (dst))
12 #define memmove(dst, src, sz) __builtin___memmove_chk (dst, src, sz, bos (dst))
13 #define strncpy(dst, src, sz) __builtin___strncpy_chk (dst, src, sz, bos (dst))
14 #define strncat(dst, src, sz) __builtin___strncat_chk (dst, src, sz, bos (dst))
15 #define stpncpy(dst, src, sz) __builtin___stpncpy_chk (dst, src, sz, bos (dst))
16 
17 struct A { short a, b; int c, d; long e, f; };
18 typedef struct A TA;
19 typedef struct A *PA;
20 typedef TA *PTA;
21 struct B {};
22 typedef struct B TB;
23 typedef struct B *PB;
24 typedef TB *PTB;
25 typedef int X[3][3][3];
26 
27 void
28 f1 (void *x)
29 {
30   struct A a, *pa1 = &a;
31   TA *pa2 = &a;
32   PA pa3 = &a;
33   PTA pa4 = &a;
34   memset (&a, 0, sizeof (&a));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
35   memset (pa1, 0, sizeof (pa1));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
36   memset (pa2, 0, sizeof pa2);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
37   memset (pa3, 0, sizeof (pa3));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
38   memset (pa4, 0, sizeof pa4);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
39   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" } */
40   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" } */
41   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" } */
42   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" } */
43 
44   memcpy (&a, x, sizeof (&a));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
45   memcpy (pa1, x, sizeof (pa1));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
46   memcpy (pa2, x, sizeof pa2);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
47   memcpy (pa3, x, sizeof (pa3));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
48   memcpy (pa4, x, sizeof pa4);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
49   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" } */
50   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" } */
51   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" } */
52   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" } */
53 
54   memcpy (x, &a, sizeof (&a));		    /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
55   memcpy (x, pa1, sizeof (pa1));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
56   memcpy (x, pa2, sizeof pa2);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
57   memcpy (x, pa3, sizeof (pa3));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
58   memcpy (x, pa4, sizeof pa4);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
59   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" } */
60   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" } */
61   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" } */
62   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" } */
63 
64   memmove (&a, x, sizeof (&a));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
65   memmove (pa1, x, sizeof (pa1));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
66   memmove (pa2, x, sizeof pa2);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
67   memmove (pa3, x, sizeof (pa3));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
68   memmove (pa4, x, sizeof pa4);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
69   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" } */
70   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" } */
71   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" } */
72   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" } */
73 
74   memmove (x, &a, sizeof (&a));		    /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
75   memmove (x, pa1, sizeof (pa1));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
76   memmove (x, pa2, sizeof pa2);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
77   memmove (x, pa3, sizeof (pa3));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
78   memmove (x, pa4, sizeof pa4);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
79   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" } */
80   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" } */
81   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" } */
82   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" } */
83 
84   /* These are correct, no warning.  */
85   memset (&a, 0, sizeof a);
86   memset (&a, 0, sizeof (a));
87   memset (&a, 0, sizeof (struct A));
88   memset (&a, 0, sizeof (const struct A));
89   memset (&a, 0, sizeof (volatile struct A));
90   memset (&a, 0, sizeof (volatile const struct A));
91   memset (&a, 0, sizeof (TA));
92   memset (&a, 0, sizeof (__typeof (*&a)));
93   memset (pa1, 0, sizeof (*pa1));
94   memset (pa2, 0, sizeof (*pa3));
95   memset (pa3, 0, sizeof (__typeof (*pa3)));
96   /* These are probably broken, but obfuscated, no warning.  */
97   memset ((void *) &a, 0, sizeof (&a));
98   memset ((char *) &a, 0, sizeof (&a));
99   memset (&a, 0, sizeof (&a) + 0);
100   memset (&a, 0, 0 + sizeof (&a));
101 
102   /* These are correct, no warning.  */
103   memcpy (&a, x, sizeof a);
104   memcpy (&a, x, sizeof (a));
105   memcpy (&a, x, sizeof (struct A));
106   memcpy (&a, x, sizeof (const struct A));
107   memcpy (&a, x, sizeof (volatile struct A));
108   memcpy (&a, x, sizeof (volatile const struct A));
109   memcpy (&a, x, sizeof (TA));
110   memcpy (&a, x, sizeof (__typeof (*&a)));
111   memcpy (pa1, x, sizeof (*pa1));
112   memcpy (pa2, x, sizeof (*pa3));
113   memcpy (pa3, x, sizeof (__typeof (*pa3)));
114   /* These are probably broken, but obfuscated, no warning.  */
115   memcpy ((void *) &a, x, sizeof (&a));
116   memcpy ((char *) &a, x, sizeof (&a));
117   memcpy (&a, x, sizeof (&a) + 0);
118   memcpy (&a, x, 0 + sizeof (&a));
119 
120   /* These are correct, no warning.  */
121   memcpy (x, &a, sizeof a);
122   memcpy (x, &a, sizeof (a));
123   memcpy (x, &a, sizeof (struct A));
124   memcpy (x, &a, sizeof (const struct A));
125   memcpy (x, &a, sizeof (volatile struct A));
126   memcpy (x, &a, sizeof (volatile const struct A));
127   memcpy (x, &a, sizeof (TA));
128   memcpy (x, &a, sizeof (__typeof (*&a)));
129   memcpy (x, pa1, sizeof (*pa1));
130   memcpy (x, pa2, sizeof (*pa3));
131   memcpy (x, pa3, sizeof (__typeof (*pa3)));
132   /* These are probably broken, but obfuscated, no warning.  */
133   memcpy (x, (void *) &a, sizeof (&a));
134   memcpy (x, (char *) &a, sizeof (&a));
135   memcpy (x, &a, sizeof (&a) + 0);
136   memcpy (x, &a, 0 + sizeof (&a));
137 
138   /* These are correct, no warning.  */
139   memmove (&a, x, sizeof a);
140   memmove (&a, x, sizeof (a));
141   memmove (&a, x, sizeof (struct A));
142   memmove (&a, x, sizeof (const struct A));
143   memmove (&a, x, sizeof (volatile struct A));
144   memmove (&a, x, sizeof (volatile const struct A));
145   memmove (&a, x, sizeof (TA));
146   memmove (&a, x, sizeof (__typeof (*&a)));
147   memmove (pa1, x, sizeof (*pa1));
148   memmove (pa2, x, sizeof (*pa3));
149   memmove (pa3, x, sizeof (__typeof (*pa3)));
150   /* These are probably broken, but obfuscated, no warning.  */
151   memmove ((void *) &a, x, sizeof (&a));
152   memmove ((char *) &a, x, sizeof (&a));
153   memmove (&a, x, sizeof (&a) + 0);
154   memmove (&a, x, 0 + sizeof (&a));
155 
156   /* These are correct, no warning.  */
157   memmove (x, &a, sizeof a);
158   memmove (x, &a, sizeof (a));
159   memmove (x, &a, sizeof (struct A));
160   memmove (x, &a, sizeof (const struct A));
161   memmove (x, &a, sizeof (volatile struct A));
162   memmove (x, &a, sizeof (volatile const struct A));
163   memmove (x, &a, sizeof (TA));
164   memmove (x, &a, sizeof (__typeof (*&a)));
165   memmove (x, pa1, sizeof (*pa1));
166   memmove (x, pa2, sizeof (*pa3));
167   memmove (x, pa3, sizeof (__typeof (*pa3)));
168   /* These are probably broken, but obfuscated, no warning.  */
169   memmove (x, (void *) &a, sizeof (&a));
170   memmove (x, (char *) &a, sizeof (&a));
171   memmove (x, &a, sizeof (&a) + 0);
172   memmove (x, &a, 0 + sizeof (&a));
173 }
174 
175 void
176 f2 (void *x)
177 {
178   struct B b, *pb1 = &b;
179   TB *pb2 = &b;
180   PB pb3 = &b;
181   PTB pb4 = &b;
182   memset (&b, 0, sizeof (&b));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
183   memset (pb1, 0, sizeof (pb1));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
184   memset (pb2, 0, sizeof pb2);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
185   memset (pb3, 0, sizeof (pb3));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
186   memset (pb4, 0, sizeof pb4);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
187   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" } */
188   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" } */
189   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" } */
190   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" } */
191 
192   memcpy (&b, x, sizeof (&b));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
193   memcpy (pb1, x, sizeof (pb1));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
194   memcpy (pb2, x, sizeof pb2);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
195   memcpy (pb3, x, sizeof (pb3));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
196   memcpy (pb4, x, sizeof pb4);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
197   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" } */
198   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" } */
199   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" } */
200   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" } */
201 
202   memcpy (x, &b, sizeof (&b));		    /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
203   memcpy (x, pb1, sizeof (pb1));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
204   memcpy (x, pb2, sizeof pb2);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
205   memcpy (x, pb3, sizeof (pb3));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
206   memcpy (x, pb4, sizeof pb4);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
207   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" } */
208   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" } */
209   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" } */
210   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" } */
211 
212   memmove (&b, x, sizeof (&b));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
213   memmove (pb1, x, sizeof (pb1));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
214   memmove (pb2, x, sizeof pb2);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
215   memmove (pb3, x, sizeof (pb3));	    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
216   memmove (pb4, x, sizeof pb4);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
217   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" } */
218   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" } */
219   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" } */
220   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" } */
221 
222   memmove (x, &b, sizeof (&b));		    /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
223   memmove (x, pb1, sizeof (pb1));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
224   memmove (x, pb2, sizeof pb2);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
225   memmove (x, pb3, sizeof (pb3));	    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
226   memmove (x, pb4, sizeof pb4);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
227   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" } */
228   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" } */
229   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" } */
230   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" } */
231 
232   /* These are correct, no warning.  */
233   memset (&b, 0, sizeof b);
234   memset (&b, 0, sizeof (b));
235   memset (&b, 0, sizeof (struct B));
236   memset (&b, 0, sizeof (const struct B));
237   memset (&b, 0, sizeof (volatile struct B));
238   memset (&b, 0, sizeof (volatile const struct B));
239   memset (&b, 0, sizeof (TB));
240   memset (&b, 0, sizeof (__typeof (*&b)));
241   memset (pb1, 0, sizeof (*pb1));
242   memset (pb2, 0, sizeof (*pb3));
243   memset (pb3, 0, sizeof (__typeof (*pb3)));
244   /* These are probably broken, but obfuscated, no warning.  */
245   memset ((void *) &b, 0, sizeof (&b));
246   memset ((char *) &b, 0, sizeof (&b));
247   memset (&b, 0, sizeof (&b) + 0);
248   memset (&b, 0, 0 + sizeof (&b));
249 
250   /* These are correct, no warning.  */
251   memcpy (&b, x, sizeof b);
252   memcpy (&b, x, sizeof (b));
253   memcpy (&b, x, sizeof (struct B));
254   memcpy (&b, x, sizeof (const struct B));
255   memcpy (&b, x, sizeof (volatile struct B));
256   memcpy (&b, x, sizeof (volatile const struct B));
257   memcpy (&b, x, sizeof (TB));
258   memcpy (&b, x, sizeof (__typeof (*&b)));
259   memcpy (pb1, x, sizeof (*pb1));
260   memcpy (pb2, x, sizeof (*pb3));
261   memcpy (pb3, x, sizeof (__typeof (*pb3)));
262   /* These are probably broken, but obfuscated, no warning.  */
263   memcpy ((void *) &b, x, sizeof (&b));
264   memcpy ((char *) &b, x, sizeof (&b));
265   memcpy (&b, x, sizeof (&b) + 0);
266   memcpy (&b, x, 0 + sizeof (&b));
267 
268   /* These are correct, no warning.  */
269   memcpy (x, &b, sizeof b);
270   memcpy (x, &b, sizeof (b));
271   memcpy (x, &b, sizeof (struct B));
272   memcpy (x, &b, sizeof (const struct B));
273   memcpy (x, &b, sizeof (volatile struct B));
274   memcpy (x, &b, sizeof (volatile const struct B));
275   memcpy (x, &b, sizeof (TB));
276   memcpy (x, &b, sizeof (__typeof (*&b)));
277   memcpy (x, pb1, sizeof (*pb1));
278   memcpy (x, pb2, sizeof (*pb3));
279   memcpy (x, pb3, sizeof (__typeof (*pb3)));
280   /* These are probably broken, but obfuscated, no warning.  */
281   memcpy (x, (void *) &b, sizeof (&b));
282   memcpy (x, (char *) &b, sizeof (&b));
283   memcpy (x, &b, sizeof (&b) + 0);
284   memcpy (x, &b, 0 + sizeof (&b));
285 
286   /* These are correct, no warning.  */
287   memmove (&b, x, sizeof b);
288   memmove (&b, x, sizeof (b));
289   memmove (&b, x, sizeof (struct B));
290   memmove (&b, x, sizeof (const struct B));
291   memmove (&b, x, sizeof (volatile struct B));
292   memmove (&b, x, sizeof (volatile const struct B));
293   memmove (&b, x, sizeof (TB));
294   memmove (&b, x, sizeof (__typeof (*&b)));
295   memmove (pb1, x, sizeof (*pb1));
296   memmove (pb2, x, sizeof (*pb3));
297   memmove (pb3, x, sizeof (__typeof (*pb3)));
298   /* These are probably broken, but obfuscated, no warning.  */
299   memmove ((void *) &b, x, sizeof (&b));
300   memmove ((char *) &b, x, sizeof (&b));
301   memmove (&b, x, sizeof (&b) + 0);
302   memmove (&b, x, 0 + sizeof (&b));
303 
304   /* These are correct, no warning.  */
305   memmove (x, &b, sizeof b);
306   memmove (x, &b, sizeof (b));
307   memmove (x, &b, sizeof (struct B));
308   memmove (x, &b, sizeof (const struct B));
309   memmove (x, &b, sizeof (volatile struct B));
310   memmove (x, &b, sizeof (volatile const struct B));
311   memmove (x, &b, sizeof (TB));
312   memmove (x, &b, sizeof (__typeof (*&b)));
313   memmove (x, pb1, sizeof (*pb1));
314   memmove (x, pb2, sizeof (*pb3));
315   memmove (x, pb3, sizeof (__typeof (*pb3)));
316   /* These are probably broken, but obfuscated, no warning.  */
317   memmove (x, (void *) &b, sizeof (&b));
318   memmove (x, (char *) &b, sizeof (&b));
319   memmove (x, &b, sizeof (&b) + 0);
320   memmove (x, &b, 0 + sizeof (&b));
321 }
322 
323 void
324 f3 (void *x, char *y, int z, X w)
325 {
326   unsigned char *y1 = (unsigned char *) __builtin_alloca (z + 16);
327   char buf1[7];
328   signed char buf2[z + 32];
329   long buf3[17];
330   int *buf4[9];
331   signed char *y2 = buf2;
332   char c;
333   char *y3;
334   memset (y, 0, sizeof (y));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
335   memset (y1, 0, sizeof (y1));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
336   memset (y2, 0, sizeof (y2));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
337   memset (&c, 0, sizeof (&c));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
338   memset (w, 0, sizeof w);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
339 
340   memcpy (y, x, sizeof (y));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
341   memcpy (y1, x, sizeof (y1));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
342   memcpy (y2, x, sizeof (y2));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
343   memcpy (&c, x, sizeof (&c));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
344   memcpy (w, x, sizeof w);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
345 
346   memcpy (x, y, sizeof (y));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
347   memcpy (x, y1, sizeof (y1));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
348   memcpy (x, y2, sizeof (y2));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
349   memcpy (x, &c, sizeof (&c));		    /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
350   memcpy (x, w, sizeof w);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
351 
352   memmove (y, x, sizeof (y));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
353   memmove (y1, x, sizeof (y1));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
354   memmove (y2, x, sizeof (y2));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
355   memmove (&c, x, sizeof (&c));		    /* { dg-warning "call is the same expression as the destination; did you mean to remove the addressof" } */
356   memmove (w, x, sizeof w);		    /* { dg-warning "call is the same expression as the destination; did you mean to dereference it" } */
357 
358   memmove (x, y, sizeof (y));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
359   memmove (x, y1, sizeof (y1));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
360   memmove (x, y2, sizeof (y2));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
361   memmove (x, &c, sizeof (&c));		    /* { dg-warning "call is the same expression as the source; did you mean to remove the addressof" } */
362   memmove (x, w, sizeof w);		    /* { dg-warning "call is the same expression as the source; did you mean to dereference it" } */
363 
364   /* These are correct, no warning.  */
365   memset (y, 0, sizeof (*y));
366   memset (y1, 0, sizeof (*y2));
367   memset (buf1, 0, sizeof buf1);
368   memset (buf3, 0, sizeof (buf3));
369   memset (&buf3[0], 0, sizeof (buf3));
370   memset (&buf4[0], 0, sizeof (buf4));
371   memset (w, 0, sizeof (X));
372   /* These are probably broken, but obfuscated, no warning.  */
373   memset ((void *) y, 0, sizeof (y));
374   memset ((char *) y1, 0, sizeof (y2));
375   memset (y, 0, sizeof (y) + 0);
376   memset (y1, 0, 0 + sizeof (y2));
377   memset ((void *) &c, 0, sizeof (&c));
378   memset ((signed char *) &c, 0, sizeof (&c));
379   memset (&c, 0, sizeof (&c) + 0);
380   memset (&c, 0, 0 + sizeof (&c));
381 
382   /* These are correct, no warning.  */
383   memcpy (y, x, sizeof (*y));
384   memcpy (y1, x, sizeof (*y2));
385   memcpy (buf1, x, sizeof buf1);
386   memcpy (buf3, x, sizeof (buf3));
387   memcpy (&buf3[0], x, sizeof (buf3));
388   memcpy (&buf4[0], x, sizeof (buf4));
389   memcpy (&y3, y, sizeof (y3));
390   memcpy ((char *) &y3, y, sizeof (y3));
391   memcpy (w, x, sizeof (X));
392   /* These are probably broken, but obfuscated, no warning.  */
393   memcpy ((void *) y, x, sizeof (y));
394   memcpy ((char *) y1, x, sizeof (y2));
395   memcpy (y, x, sizeof (y) + 0);
396   memcpy (y1, x, 0 + sizeof (y2));
397   memcpy ((void *) &c, x, sizeof (&c));
398   memcpy ((signed char *) &c, x, sizeof (&c));
399   memcpy (&c, x, sizeof (&c) + 0);
400   memcpy (&c, x, 0 + sizeof (&c));
401 
402   /* These are correct, no warning.  */
403   memcpy (x, y, sizeof (*y));
404   memcpy (x, y1, sizeof (*y2));
405   memcpy (x, buf1, sizeof buf1);
406   memcpy (x, buf3, sizeof (buf3));
407   memcpy (x, &buf3[0], sizeof (buf3));
408   memcpy (x, &buf4[0], sizeof (buf4));
409   memcpy (y, &y3, sizeof (y3));
410   memcpy (y, (char *) &y3, sizeof (y3));
411   memcpy (x, w, sizeof (X));
412   /* These are probably broken, but obfuscated, no warning.  */
413   memcpy (x, (void *) y, sizeof (y));
414   memcpy (x, (char *) y1, sizeof (y2));
415   memcpy (x, y, sizeof (y) + 0);
416   memcpy (x, y1, 0 + sizeof (y2));
417   memcpy (x, (void *) &c, sizeof (&c));
418   memcpy (x, (signed char *) &c, sizeof (&c));
419   memcpy (x, &c, sizeof (&c) + 0);
420   memcpy (x, &c, 0 + sizeof (&c));
421 
422   /* These are correct, no warning.  */
423   memmove (y, x, sizeof (*y));
424   memmove (y1, x, sizeof (*y2));
425   memmove (buf1, x, sizeof buf1);
426   memmove (buf3, x, sizeof (buf3));
427   memmove (&buf3[0], x, sizeof (buf3));
428   memmove (&buf4[0], x, sizeof (buf4));
429   memmove (&y3, y, sizeof (y3));
430   memmove ((char *) &y3, y, sizeof (y3));
431   memmove (w, x, sizeof (X));
432   /* These are probably broken, but obfuscated, no warning.  */
433   memmove ((void *) y, x, sizeof (y));
434   memmove ((char *) y1, x, sizeof (y2));
435   memmove (y, x, sizeof (y) + 0);
436   memmove (y1, x, 0 + sizeof (y2));
437   memmove ((void *) &c, x, sizeof (&c));
438   memmove ((signed char *) &c, x, sizeof (&c));
439   memmove (&c, x, sizeof (&c) + 0);
440   memmove (&c, x, 0 + sizeof (&c));
441 
442   /* These are correct, no warning.  */
443   memmove (x, y, sizeof (*y));
444   memmove (x, y1, sizeof (*y2));
445   memmove (x, buf1, sizeof buf1);
446   memmove (x, buf3, sizeof (buf3));
447   memmove (x, &buf3[0], sizeof (buf3));
448   memmove (x, &buf4[0], sizeof (buf4));
449   memmove (y, &y3, sizeof (y3));
450   memmove (y, (char *) &y3, sizeof (y3));
451   memmove (x, w, sizeof (X));
452   /* These are probably broken, but obfuscated, no warning.  */
453   memmove (x, (void *) y, sizeof (y));
454   memmove (x, (char *) y1, sizeof (y2));
455   memmove (x, y, sizeof (y) + 0);
456   memmove (x, y1, 0 + sizeof (y2));
457   memmove (x, (void *) &c, sizeof (&c));
458   memmove (x, (signed char *) &c, sizeof (&c));
459   memmove (x, &c, sizeof (&c) + 0);
460   memmove (x, &c, 0 + sizeof (&c));
461 }
462 
463 void
464 f4 (char *x, char **y, int z, char w[64])
465 {
466   const char *s1 = "foobarbaz";
467   const char *s2 = "abcde12345678";
468   strncpy (x, s1, sizeof (s1));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
469   strncat (x, s2, sizeof (s2));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
470   stpncpy (x, s1, sizeof (s1));		    /* { dg-warning "call is the same expression as the source; did you mean to provide an explicit length" } */
471 
472   strncpy (w, s1, sizeof (w));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
473   strncat (w, s2, sizeof (w));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
474   stpncpy (w, s1, sizeof (w));		    /* { dg-warning "call is the same expression as the destination; did you mean to provide an explicit length" } */
475 
476   /* These are pointless when the destination is large enough, and
477      cause overflow otherwise.  If the copies are guaranteed to be
478      safe the calls might as well be replaced by strcat(), strcpy(),
479      or memcpy().  */
480   const char s3[] = "foobarbaz";
481   const char s4[] = "abcde12345678";
482   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?" } */
483   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?" } */
484   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?" } */
485 }
486 
487 /* { dg-prune-output "\[\n\r\]*writing\[\n\r\]*" } */
488 /* { dg-prune-output "\[\n\r\]*reading\[\n\r\]*" } */
489