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  }