1  /* PR middle-end/82646 - bogus -Wstringop-overflow with -D_FORTIFY_SOURCE=2
       2     on strncpy with range to a member array
       3     { dg-do compile }
       4     { dg-options "-O2 -Wstringop-overflow -ftrack-macro-expansion=0" } */
       5  
       6  #define bos(p)   __builtin_object_size (p, 1)
       7  
       8  struct S {
       9    char a[5];
      10    void (*pf)(void);
      11  };
      12  
      13  /* Verify that none of the string function calls below triggers a warning.  */
      14  
      15  char* test_stpncpy_const_nowarn (struct S *p)
      16  {
      17    int n = sizeof p->a;
      18  
      19    return __builtin_stpncpy (p->a, "123456", n);
      20  }
      21  
      22  char* test_strncpy_const_nowarn (struct S *p)
      23  {
      24    int n = sizeof p->a;
      25  
      26    return __builtin_strncpy (p->a, "1234567", n);
      27  }
      28  
      29  char* test_stpncpy_chk_const_nowarn (struct S *p)
      30  {
      31    int n = sizeof p->a;
      32  
      33    return __builtin___stpncpy_chk (p->a, "12345678", n, bos (p->a));
      34  }
      35  
      36  char* test_strncpy_chk_const_nowarn (struct S *p)
      37  {
      38    int n = sizeof p->a;
      39  
      40    return __builtin___strncpy_chk (p->a, "123456789", n, bos (p->a));
      41  }
      42  
      43  
      44  char* test_stpncpy_range_nowarn (struct S *p, int n)
      45  {
      46    if (n < sizeof p->a)
      47      n = sizeof p->a;
      48  
      49    return __builtin_stpncpy (p->a, "123456", n);
      50  }
      51  
      52  char* test_strncpy_range_nowarn (struct S *p, int n)
      53  {
      54    if (n < sizeof p->a)
      55      n = sizeof p->a;
      56  
      57    return __builtin_strncpy (p->a, "1234567", n);
      58  }
      59  
      60  char* test_stpncpy_chk_range_nowarn (struct S *p, int n)
      61  {
      62    if (n < sizeof p->a)
      63      n = sizeof p->a;
      64  
      65    return __builtin___stpncpy_chk (p->a, "12345678", n, bos (p->a));   /* { dg-bogus "\\\[-Wstringop-overflow=]" } */
      66  }
      67  
      68  char* test_strncpy_chk_range_nowarn (struct S *p, int n)
      69  {
      70    if (n < sizeof p->a)
      71      n = sizeof p->a;
      72  
      73    return __builtin___strncpy_chk (p->a, "123456789", n, bos (p->a));  /* { dg-bogus "\\\[-Wstringop-overflow=]" } */
      74  }
      75  
      76  
      77  /* Verify that all of the string function calls below trigger a warning.  */
      78  
      79  char* test_stpncpy_const_warn (struct S *p)
      80  {
      81    int n = sizeof p->a;
      82  
      83    ++n;
      84  
      85    return __builtin_stpncpy (p->a, "123456", n);                       /* { dg-warning "\\\[-Wstringop-overflow=]" } */
      86  }
      87  
      88  char* test_strncpy_const_warn (struct S *p)
      89  {
      90    int n = sizeof p->a;
      91  
      92    /* A call to strncpy() with a known string and small bound is folded
      93       into memcpy() which defeats the warning in this case since memcpy
      94       uses Object Size Type 0, i.e., the largest object that p->a may
      95       be a part of.  Use a larger bound to get around this here.  */
      96    n += 11;
      97  
      98    return __builtin_strncpy (p->a, "1234567", n);                      /* { dg-warning "\\\[-Wstringop-overflow=]" } */
      99  }
     100  
     101  char* test_stpncpy_chk_const_warn (struct S *p)
     102  {
     103    int n = sizeof p->a;
     104  
     105    ++n;
     106  
     107    return __builtin___stpncpy_chk (p->a, "12345678", n, bos (p->a));   /* { dg-warning "\\\[-Wstringop-overflow=]" } */
     108  }
     109  
     110  char* test_strncpy_chk_const_warn (struct S *p)
     111  {
     112    int n = sizeof p->a;
     113  
     114    ++n;
     115  
     116    return __builtin___strncpy_chk (p->a, "123456789", n, bos (p->a));  /* { dg-warning "\\\[-Wstringop-overflow=]" } */
     117  }
     118  
     119  
     120  char* test_stpncpy_range_warn (struct S *p, int n)
     121  {
     122    if (n < sizeof p->a + 1)
     123      n = sizeof p->a + 1;
     124  
     125    return __builtin_stpncpy (p->a, "123456", n);                       /* { dg-warning "\\\[-Wstringop-overflow=]" } */
     126  }
     127  
     128  char* test_strncpy_range_warn (struct S *p, int n)
     129  {
     130    if (n < sizeof p->a + 1)
     131      n = sizeof p->a + 1;
     132  
     133    return __builtin_strncpy (p->a, "1234567", n);                      /* { dg-warning "\\\[-Wstringop-overflow=]" } */
     134  }
     135  
     136  char* test_stpncpy_chk_range_warn (struct S *p, int n)
     137  {
     138    if (n < sizeof p->a + 1)
     139      n = sizeof p->a + 1;
     140  
     141    return __builtin___stpncpy_chk (p->a, "12345678", n, bos (p->a));   /* { dg-warning "\\\[-Wstringop-overflow=]" } */
     142  }
     143  
     144  char* test_strncpy_chk_range_warn (struct S *p, int n)
     145  {
     146    if (n < sizeof p->a + 1)
     147      n = sizeof p->a + 1;
     148  
     149    return __builtin___strncpy_chk (p->a, "123456789", n, bos (p->a));  /* { dg-warning "\\\[-Wstringop-overflow=]" } */
     150  }