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