gcc/testsuite/c-c++-common/Warray-bounds-2.c

   1 /* Test to exercise that -Warray-bounds warnings for memory and string
   2    functions are issued even when they are declared in system headers
   3    (i.e., not just when they are explicitly declared in the source
   4    file.)
   5    Also verify that the warnings are issued even for calls where the
   6    source of the excessive array bound is in a different function than
   7    the call.
   8    { dg-do compile }
   9    { dg-options "-O2 -Warray-bounds -Wno-stringop-overflow" } */
  10
  11 #include <stddef.h>
  12 #include <string.h>
  13
  14 #define MAX  (__SIZE_MAX__ / 2)
  15
  16 void sink (void*);
  17
  18 struct __attribute__ ((packed)) Array
  19 {
  20   char a13[13];
  21   char a15[15];
  22   char a17[17];
  23 };
  24
  25 /* Exercise memcpy out-of-bounds offsets with an array of known size.  */
  26
  27 static void
  28 wrap_memcpy_src_xsize (char *d, const char *s, ptrdiff_t i, size_t n)
  29 {
  30   memcpy (d, s + i, n);   /* { dg-warning "offset 46 is out of the bounds \\\[0, 45] of object .ar. with type .(struct )?Array." "memcpy" } */
  31 }
  32
  33 void call_memcpy_src_xsize (char *d, size_t n)
  34 {
  35   struct Array ar;
  36   sink (&ar);
  37   wrap_memcpy_src_xsize (d, ar.a13, 46, n);
  38   sink (&ar);
  39 }
  40
  41 /* Exercise memcpy out-of-bounds offsets with an array of unknown size.  */
  42
  43 static void
  44 wrap_memcpy_src_diff_max (char *d, const char *s, ptrdiff_t i, size_t n)
  45 {
  46   memcpy (d, s + i, n);   /* { dg-warning "pointer overflow between offset \[0-9\]+ and size 3" "memcpy" } */
  47 }
  48
  49 void call_memcpy_src_diff_max (char *d, const char *s, size_t n)
  50 {
  51   wrap_memcpy_src_diff_max (d, s, MAX, 3);
  52 }
  53
  54 static void
  55 wrap_memcpy_dst_xsize (char *d, const char *s, ptrdiff_t i, size_t n)
  56 {
  57   memcpy (d + i, s, n);   /* { dg-warning "offset 47 is out of the bounds \\\[0, 45] of object .ar1. with type .(struct )?Array." "memcpy" } */
  58 }
  59
  60 void call_memcpy_dst_xsize (const char *s, size_t n)
  61 {
  62   struct Array ar1;       /* { dg-message ".ar1. declared here" } */
  63   sink (&ar1);
  64   wrap_memcpy_dst_xsize (ar1.a15, s, 34, n);
  65   sink (&ar1);
  66 }
  67
  68 static void
  69 wrap_memcpy_dst_diff_max (char *d, const char *s, ptrdiff_t i, size_t n)
  70 {
  71   memcpy (d + i, s, n);   /* { dg-warning "offset -?\[0-9\]+ is out of the bounds \\\[0, 45] of object .ar2. with type .(struct )?Array." "memcpy" } */
  72 }
  73
  74 void call_memcpy_dst_diff_max (const char *s, size_t n)
  75 {
  76   struct Array ar2;       /* { dg-message ".ar2. declared here" } */
  77   sink (&ar2);
  78   wrap_memcpy_dst_diff_max (ar2.a15, s, MAX, n);
  79   sink (&ar2);
  80 }
  81
  82
  83 static void wrap_strcat_src_xsize (char *d, const char *s, ptrdiff_t i)
  84 {
  85   strcat (d, s + i);   /* { dg-warning "offset 46 is out of the bounds \\\[0, 45] of object .ar3. with type .(struct )?Array." "strcat" } */
  86 }
  87
  88 void call_strcat_src_xsize (char *d)
  89 {
  90   struct Array ar3;       /* { dg-message ".ar3. declared here" } */
  91   sink (&ar3);
  92   wrap_strcat_src_xsize (d, ar3.a15, 15 + 17 + 1);
  93   sink (&ar3);
  94 }
  95
  96 static void wrap_strcat_dst_xsize (char *d, const char *s, ptrdiff_t i)
  97 {
  98   strcat (d + i, s);   /* { dg-warning "offset 47 is out of the bounds \\\[0, 45] of object .ar4. with type .(struct )?Array." "strcat" } */
  99 }
 100
 101 void call_strcat_dst_xsize (const char *s)
 102 {
 103   struct Array ar4;       /* { dg-message ".ar4. declared here" } */
 104   sink (&ar4);
 105   wrap_strcat_dst_xsize (ar4.a15, s, 15 + 17 + 2);
 106   sink (&ar4);
 107 }
 108
 109
 110 static void wrap_strcpy_src_xsize (char *d, const char *s, ptrdiff_t i)
 111 {
 112   strcpy (d, s + i);   /* { dg-warning "offset 48 is out of the bounds \\\[0, 45] of object .ar5. with type .(struct )?Array." "strcpy" } */
 113 }
 114
 115 void call_strcpy_src_xsize (char *d)
 116 {
 117   struct Array ar5;       /* { dg-message ".ar5. declared here" } */
 118   sink (&ar5);
 119   wrap_strcpy_src_xsize (d, ar5.a15, 15 + 17 + 3);
 120   sink (&ar5);
 121 }
 122
 123 static void wrap_strcpy_dst_xsize (char *d, const char *s, ptrdiff_t i)
 124 {
 125   strcpy (d + i, s);   /* { dg-warning "offset 49 is out of the bounds \\\[0, 45] of object .ar6. with type .(struct )?Array." "strcpy" } */
 126 }
 127
 128 void call_strcpy_dst_xsize (const char *s)
 129 {
 130   struct Array ar6;       /* { dg-message ".ar6. declared here" } */
 131   sink (&ar6);
 132   wrap_strcpy_dst_xsize (ar6.a15, s, 15 + 17 + 4);
 133   sink (&ar6);
 134 }
 135
 136
 137 /* Exercise strncpy out-of-bounds offsets with an array of known size.  */
 138
 139 static void
 140 wrap_strncpy_src_xsize (char *d, const char *s, ptrdiff_t i, size_t n)
 141 {
 142   strncpy (d, s + i, n);   /* { dg-warning "offset 46 is out of the bounds \\\[0, 45] of object .ar7. with type '(struct )?Array." "strncpy" } */
 143 }
 144
 145 void call_strncpy_src_xsize (char *d, size_t n)
 146 {
 147   struct Array ar7;       /* { dg-message ".ar7. declared here" } */
 148   sink (&ar7);
 149   wrap_strncpy_src_xsize (d, ar7.a17, 17 + 1, n);
 150   sink (&ar7);
 151 }
 152
 153 /* Exercise strncpy out-of-bounds offsets with an array of unknown size.  */
 154
 155 static void
 156 wrap_strncpy_src_diff_max (char *d, const char *s, ptrdiff_t i, size_t n)
 157 {
 158   /* Unlike in the similar call to memcpy(), there is no pointer
 159      overflow here because the size N is not added to the source
 160      offset.  */
 161   strncpy (d, s + i, n);
 162 }
 163
 164 void call_strncpy_src_diff_max (char *d, const char *s, size_t n)
 165 {
 166   wrap_strncpy_src_diff_max (d, s, MAX, 3);
 167 }
 168
 169 static void
 170 wrap_strncpy_dst_xsize (char *d, const char *s, ptrdiff_t i, size_t n)
 171 {
 172   strncpy (d + i, s, n);   /* { dg-warning "offset 47 is out of the bounds \\\[0, 45] of object .ar8. with type .(struct )?Array." "strncpy" } */
 173 }
 174
 175 void call_strncpy_dst_xsize (const char *s, size_t n)
 176 {
 177   struct Array ar8;       /* { dg-message ".ar8. declared here" } */
 178   sink (&ar8);
 179   wrap_strncpy_dst_xsize (ar8.a17, s, 17 + 2, n);
 180   sink (&ar8);
 181 }
 182
 183 static void
 184 wrap_strncpy_dst_diff_max (char *d, const char *s, ptrdiff_t i, size_t n)
 185 {
 186   strncpy (d + i, s, n);   /* { dg-warning "offset -\[0-9\]+ is out of the bounds \\\[0, 45] of object .ar9. with type .(struct )?Array." "strncpy" } */
 187 }
 188
 189 void call_strncpy_dst_diff_max (const char *s, size_t n)
 190 {
 191   struct Array ar9;       /* { dg-message ".ar9. declared here" "strncpy" } */
 192   sink (&ar9);
 193   wrap_strncpy_dst_diff_max (ar9.a17, s, MAX, n);
 194   sink (&ar9);
 195 }
 196
 197 static void
 198 wrap_strncpy_dstarray_diff_neg (char *d, const char *s, ptrdiff_t i, size_t n)
 199 {
 200   strncpy (d + i, s, n);   /* { dg-warning "offset -\[0-9\]+ is out of the bounds \\\[0, 90] of object .ar10. with type .(struct )?Array ?\\\[2]." "strncpy" } */
 201 }
 202
 203 void call_strncpy_dstarray_diff_neg (const char *s, size_t n)
 204 {
 205   struct Array ar10[2];    /* { dg-message ".ar10. declared here" } */
 206   sink (&ar10);
 207
 208   int off = (char*)ar10[1].a17 - (char*)ar10 + 1;
 209   wrap_strncpy_dstarray_diff_neg (ar10[1].a17, s, -off, n);
 210
 211   sink (&ar10);
 212 }