|
111
|
1 /* Test -Wsizeof-pointer-memaccess warnings. */
|
|
|
2 /* { dg-do compile } */
|
|
131
|
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} } */
|
|
111
|
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
|
|
131
|
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(). */
|
|
111
|
480 const char s3[] = "foobarbaz";
|
|
|
481 const char s4[] = "abcde12345678";
|
|
131
|
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?" } */
|
|
111
|
485 }
|
|
|
486
|
|
|
487 /* { dg-prune-output "\[\n\r\]*writing\[\n\r\]*" } */
|
|
|
488 /* { dg-prune-output "\[\n\r\]*reading\[\n\r\]*" } */
|
