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