gcc/testsuite/gcc.dg/Wstringop-overflow-56.c

   1 /* PR middle-end/92942 - missing -Wstringop-overflow for allocations with
   2    a negative lower bound size
   3    { dg-do compile }
   4    { dg-options "-O2 -Wall" }
   5    { dg-require-effective-target alloca } */
   6
   7 #define SIZE_MAX        __SIZE_MAX__
   8 #define UINT8_MAX       __UINT8_MAX__
   9 #define UINT16_MAX      __UINT16_MAX__
  10
  11 typedef __SIZE_TYPE__   size_t;
  12 typedef __UINT8_TYPE__  uint8_t;
  13 typedef __UINT16_TYPE__ uint16_t;
  14
  15 void* usr_alloc1 (size_t) __attribute__ ((alloc_size (1)));
  16 void* usr_alloc2 (size_t, size_t)  __attribute__ ((alloc_size (1, 2)));
  17
  18 void* malloc (size_t);
  19 void* memcpy (void*, const void*, size_t);
  20 void* memset (void*, int, size_t);
  21 char* strcpy (char*, const char*);
  22
  23 void sink (void*);
  24
  25 void malloc_uint_range_strcpy (unsigned n)
  26 {
  27   void *p = malloc (5 < n ? 5 : n);
  28
  29   strcpy (p, "01234");              // { dg-warning "\\\[-Wstringop-overflow" }
  30   sink (p);
  31
  32   strcpy (p, "0123");
  33   sink (p);
  34 }
  35
  36 void malloc_uint16_anti_range_memset (uint16_t n)
  37 {
  38   if (5 <= n && n <= 9) return;
  39   void *p = malloc (n);
  40
  41   if (UINT16_MAX < SIZE_MAX)
  42     {
  43       size_t sz = (uint16_t)-1 + (size_t)1;
  44       memset (p, 0, sz);            // { dg-warning "\\\[-Wstringop-overflow" }
  45       sink (p);
  46     }
  47
  48   memset (p, 0, 1);
  49   sink (p);
  50   memset (p, 0, 5);
  51   sink (p);
  52   memset (p, 0, 6);
  53   sink (p);
  54   memset (p, 0, UINT16_MAX - 1);
  55   sink (p);
  56   memset (p, 0, UINT16_MAX);
  57   sink (p);
  58 }
  59
  60 void malloc_int_strcpy (int n)
  61 {
  62   void *p = malloc (7 < n ? 7 : n);
  63
  64   strcpy (p, "0123456");            // { dg-warning "\\\[-Wstringop-overflow" }
  65   sink (p);
  66
  67   strcpy (p, "012345");
  68   sink (p);
  69 }
  70
  71 void vla_int_strcpy (int n)
  72 {
  73   char a[9 < n ? 9 : n];
  74
  75   strcpy (a, "012345678");          // { dg-warning "\\\[-Wstringop-overflow" }
  76   sink (a);
  77
  78   strcpy (a, "01234567");
  79   sink (a);
  80 }
  81
  82 void usr_alloc1_int_strcpy (int n)
  83 {
  84   void *p = usr_alloc1 (7 < n ? 7 : n);
  85
  86   strcpy (p, "0123456");            // { dg-warning "\\\[-Wstringop-overflow" }
  87   sink (p);
  88
  89   strcpy (p, "012345");
  90   sink (p);
  91 }
  92
  93 void usr_alloc2_cst_ir_strcpy (int n)
  94 {
  95   void *p = usr_alloc2 (1, 5 < n ? 5 : n);
  96
  97   strcpy (p, "01234");              // { dg-warning "\\\[-Wstringop-overflow" }
  98   sink (p);
  99
 100   strcpy (p, "0123");
 101   sink (p);
 102 }
 103
 104 void usr_alloc2_ir_ir_strcpy (int m, int n)
 105 {
 106   void *p = usr_alloc2 (3 < n ? 3 : n, 5 < n ? 5 : n);
 107
 108   strcpy (p, "0123456789abcde");    // { dg-warning "\\\[-Wstringop-overflow" }
 109   sink (p);
 110
 111   strcpy (p, "0123456789abcd");
 112   sink (p);
 113 }
 114
 115 void usr_alloc2_uint8_memset (uint8_t m, uint8_t n)
 116 {
 117   if (3 <= m && m <= 7) return;
 118   if (5 <= n && n <= 9) return;
 119   void *p = usr_alloc2 (m, n);
 120
 121   size_t sz = UINT8_MAX * UINT8_MAX + 1;
 122   memset (p, 0, sz);               // { dg-warning "\\\[-Wstringop-overflow" "" { xfail *-*-* } }
 123                                    // { dg-warning "\\\[-Warray-bounds" "pr?????" { target *-*-* } .-1 }
 124   sink (p);
 125
 126   memset (p, 0, sz - 1);
 127   sink (p);
 128   memset (p, 0, 64);
 129   sink (p);
 130   memset (p, 0, 63);
 131   sink (p);
 132   memset (p, 0, 16);
 133   sink (p);
 134   memset (p, 0, 15);
 135   sink (p);
 136   memset (p, 0, 14);
 137   sink (p);
 138   memset (p, 0, 3);
 139   sink (p);
 140 }
 141
 142
 143
 144 void malloc_int_memset (int n)
 145 {
 146   void *p = malloc (11 < n ? 11 : n);
 147
 148   memset (p, 0, 12);                // { dg-warning "\\\[-Wstringop-overflow" }
 149   sink (p);
 150
 151   memset (p, 0, 11);
 152   sink (p);
 153 }
 154
 155 void vla_int_memset (int n)
 156 {
 157   char a[13 < n ? 13 : n];
 158
 159   memset (a, 0, 14);                // { dg-warning "\\\[-Wstringop-overflow" }
 160   sink (a);
 161
 162   memset (a, 0, 13);
 163   sink (a);
 164 }