gcc/testsuite/gcc.dg/auto-init-uninit-36.c

   1 /* PR middle-end/10138 - warn for uninitialized arrays passed as const*
   2    arguments
   3    Verify that passing pointers to uninitialized objects to const
   4    arguments to built-ins is diagnosed where expected.
   5    { dg-do compile }
   6    { dg-options "-O -Wall -ftrivial-auto-var-init=zero" }
   7    { dg-require-effective-target alloca } */
   8
   9 typedef __SIZE_TYPE__ size_t;
  10
  11 void* alloca (size_t);
  12 void* malloc (size_t);
  13 void* realloc (void*, size_t);
  14
  15 void* memcpy (void*, const void*, size_t);
  16 char* strcpy (char*, const char*);
  17 size_t strlen (const char*);
  18
  19 void sink (void*);
  20
  21 void nowarn_array_memcpy (void *d, unsigned n)
  22 {
  23   int a[2];
  24   /* Diagnose this?  */
  25   memcpy (d, a, n /* Non-constant to avoid folding into MEM_REF.  */);
  26 }
  27
  28 void nowarn_array_plus_cst_memcpy (void *d, unsigned n)
  29 {
  30   int a[3];
  31   /* Diagnose this?  */
  32   memcpy (d, a + 1, n);
  33 }
  34
  35 void nowarn_array_plus_var_memcpy (void *d, unsigned n, int i)
  36 {
  37   int a[4];
  38   /* Diagnose this?  */
  39   memcpy (d, a + i, n);
  40 }
  41
  42 void nowarn_array_assign_memcpy (char *d, unsigned n)
  43 {
  44   int a[3];
  45   a[1] = 3;
  46   memcpy (d, a, n);
  47 }
  48
  49 void nowarn_array_init_memcpy (char *d, unsigned n)
  50 {
  51   int a[4] = { 0 };
  52   memcpy (d, a, n);
  53 }
  54
  55 void nowarn_array_compound_memcpy (void *d, unsigned n)
  56 {
  57   memcpy (d, (int[2]){ 0 }, n);
  58 }
  59
  60 void nowarn_struct_assign_memcpy (void *d, unsigned n)
  61 {
  62   struct S { int a, b, c, d; } s;
  63   s.b = 1;
  64   s.d = 2;
  65   memcpy (d, &s, n);
  66 }
  67
  68
  69 void nowarn_array_init_strcpy (char *d[], unsigned n)
  70 {
  71   char a[8] = "012";
  72
  73   strcpy (d[0], a);
  74   strcpy (d[1], a + 1);
  75   strcpy (d[1], a + 2);
  76   strcpy (d[1], a + 3);
  77   strcpy (d[1], a + 4);
  78   strcpy (d[1], a + 5);
  79   strcpy (d[1], a + 6);
  80   strcpy (d[1], a + 7);
  81 }
  82
  83
  84 void nowarn_array_assign_strcpy (char *d[], unsigned n)
  85 {
  86   char a[8];
  87   a[0] = '0';
  88   a[1] = '1';
  89   a[2] = '2';
  90   a[3] = '\0';
  91
  92   strcpy (d[0], a);
  93   strcpy (d[1], a + 1);
  94   strcpy (d[1], a + 2);
  95   strcpy (d[1], a + 3);
  96 }
  97
  98 void warn_array_plus_cst_strcpy (char *d, unsigned n)
  99 {
 100   char a[8];
 101   a[0] = '1';
 102   a[1] = '2';
 103   a[2] = '3';
 104   a[3] = '\0';
 105
 106   strcpy (d, a + 4);          // { dg-warning "\\\[-Wuninitialized" }
 107   strcpy (d, a + 5);          // { dg-warning "\\\[-Wuninitialized" }
 108   strcpy (d, a + 6);          // { dg-warning "\\\[-Wuninitialized" }
 109   strcpy (d, a + 7);          // { dg-warning "\\\[-Wuninitialized" }
 110 }
 111
 112 void nowarn_array_plus_var_strcpy (char *d, int i)
 113 {
 114   char a[8];
 115   a[0] = '1';
 116   a[1] = '2';
 117   a[2] = '3';
 118   a[3] = '\0';
 119
 120   strcpy (d, a + i);
 121 }
 122
 123
 124 size_t nowarn_array_assign_strlen (const char *s)
 125 {
 126   char a[8];
 127   a[0] = s[0];
 128   a[1] = s[1];
 129   a[2] = s[2];
 130   a[3] = s[3];
 131
 132   size_t n = 0;
 133
 134   n += strlen (a);
 135   n += strlen (a + 1);
 136   n += strlen (a + 2);
 137   n += strlen (a + 3);
 138   return n;
 139 }
 140
 141 size_t warn_array_plus_cst_strlen (const char *s)
 142 {
 143   char a[8];
 144   a[0] = s[0];
 145   a[1] = s[1];
 146   a[2] = s[2];
 147   a[3] = s[3];
 148
 149   return strlen (a + 4);      // { dg-warning "\\\[-Wuninitialized" }
 150 }
 151
 152 size_t nowarn_array_plus_var_strlen (const char *s, int i)
 153 {
 154   char a[8];
 155   a[0] = s[0];
 156   a[1] = s[1];
 157   a[2] = s[2];
 158   a[3] = s[3];
 159
 160   return strlen (a + i);
 161 }
 162
 163
 164 size_t nowarn_alloca_assign_strlen (int i)
 165 {
 166   char *p = (char*)alloca (8);
 167   p[i] = '\0';
 168   return strlen (p);
 169 }
 170
 171 size_t nowarn_alloca_escape_strlen (int i)
 172 {
 173   char *p = (char*)alloca (8);
 174   sink (p);
 175   return strlen (p);
 176 }
 177
 178 size_t warn_alloca_strlen (void)
 179 {
 180   char *p = (char*)alloca (8);
 181   return strlen (p);          // { dg-warning "\\\[-Wuninitialized" }
 182 }
 183
 184
 185 size_t nowarn_malloc_assign_strlen (int i)
 186 {
 187   char *p = (char*)malloc (8);
 188   p[i] = '\0';
 189   return strlen (p);
 190 }
 191
 192 size_t nowarn_malloc_escape_strlen (int i)
 193 {
 194   char *p = (char*)malloc (8);
 195   sink (p);
 196   return strlen (p);
 197 }
 198
 199 size_t warn_malloc_strlen (void)
 200 {
 201   char *p = (char*)malloc (8);
 202   return strlen (p);          // { dg-warning "\\\[-Wuninitialized" }
 203 }
 204
 205
 206 size_t nowarn_realloc_strlen (void *p)
 207 {
 208   char *q = (char*)realloc (p, 8);
 209   return strlen (q);
 210 }
 211
 212
 213 size_t nowarn_vla_assign_strlen (int n, int i)
 214 {
 215   char vla[n];
 216   vla[i] = '\0';
 217   return strlen (vla);
 218 }
 219
 220 size_t nowarn_vla_strcpy_strlen (int n, const char *s, int i)
 221 {
 222   char vla[n];
 223   strcpy (vla, s);
 224   return strlen (vla + i);
 225 }
 226
 227 size_t nowarn_vla_escape_strlen (int n, int i)
 228 {
 229   char vla[n];
 230   sink (vla);
 231   return strlen (vla);
 232 }
 233
 234 size_t warn_vla_strlen (unsigned n)
 235 {
 236   char vla[n];
 237   return strlen (vla);        // { dg-warning "\\\[-Wuninitialized" }
 238 }