gcc/testsuite/gcc.dg/attr-alloc_size-4.c

   1 /* PR c/77531 - __attribute__((alloc_size(1,2))) could also warn on
   2    multiplication overflow
   3    PR c/78284 - warn on malloc with very large arguments
   4    Test exercising the ability to detect and diagnose calls to allocation
   5    functions decorated with attribute alloc_size that either overflow or
   6    exceed the maximum object size specified by -Walloc-size-larger-than.  */
   7 /* { dg-do compile } */
   8 /* { dg-options "-O2 -Wall -Walloc-size-larger-than=1234" } */
   9
  10 #define INT_MAX    __INT_MAX__
  11 #define INT_MIN    (-INT_MAX - 1)
  12 #define UINT_MAX   (INT_MAX * 2U + 1)
  13
  14 #define SIZE_MAX   __SIZE_MAX__
  15
  16 typedef __SIZE_TYPE__ size_t;
  17
  18 #define ALLOC_SIZE(...) __attribute__ ((alloc_size (__VA_ARGS__)))
  19
  20 void* f_uint_1 (unsigned) ALLOC_SIZE (1);
  21 void* f_uint_2 (unsigned, unsigned) ALLOC_SIZE (1, 2);
  22 void* f_int_1 (int) ALLOC_SIZE (1);
  23 void* f_int_2 (int, int) ALLOC_SIZE (1, 2);
  24
  25 void* f_size_1 (size_t) ALLOC_SIZE (1);
  26 void* f_size_2 (size_t, size_t) ALLOC_SIZE (1, 2);
  27
  28 size_t
  29 unsigned_range (size_t min, size_t max)
  30 {
  31   extern size_t random_unsigned_value (void);
  32   size_t val = random_unsigned_value ();
  33   if (val < min || max < val) val = min;
  34   return val;
  35 }
  36
  37 int
  38 signed_range (int min, int max)
  39 {
  40   extern int random_signed_value (void);
  41   int val = random_signed_value ();
  42   if (val < min || max < val) val = min;
  43   return val;
  44 }
  45
  46 size_t
  47 unsigned_anti_range (size_t min, size_t max)
  48 {
  49   extern size_t random_unsigned_value (void);
  50   size_t val = random_unsigned_value ();
  51   if (min <= val && val <= max)
  52     val = min - 1;
  53   return val;
  54 }
  55
  56 int
  57 signed_anti_range (int min, int max)
  58 {
  59   extern int random_signed_value (void);
  60   int val = random_signed_value ();
  61   if (min <= val && val <= max)
  62     val = min - 1;
  63   return val;
  64 }
  65
  66 #define UR(min, max) unsigned_range (min, max)
  67 #define SR(min, max) signed_range (min, max)
  68
  69 #define UAR(min, max) unsigned_anti_range (min, max)
  70 #define SAR(min, max) signed_anti_range (min, max)
  71
  72
  73 void sink (void*);
  74
  75 void
  76 test_uint_cst (void)
  77 {
  78   const unsigned max = UINT_MAX;
  79
  80   sink (f_uint_1 (0));
  81   sink (f_uint_1 (1));
  82   sink (f_uint_1 (1233));
  83   sink (f_uint_1 (1234));
  84   sink (f_uint_1 (1235));       /* { dg-warning "argument 1 value .1235u?. exceeds maximum object size 1234" } */
  85   sink (f_uint_1 (max - 1));    /* { dg-warning "argument 1 value .\[0-9\]+u?. exceeds maximum object size 1234" } */
  86   sink (f_uint_1 (max));        /* { dg-warning "argument 1 value .\[0-9\]+u?. exceeds maximum object size 1234" } */
  87 }
  88
  89 void
  90 test_uint_range (unsigned n)
  91 {
  92   const unsigned max = UINT_MAX;
  93
  94   sink (f_uint_1 (n));
  95   sink (f_uint_1 (UR (0, 1)));
  96   sink (f_uint_1 (UR (0, 1233)));
  97   sink (f_uint_1 (UR (0, 1234)));
  98   sink (f_uint_1 (UR (0, 1235)));
  99   sink (f_uint_1 (UR (1, 1235)));
 100   sink (f_uint_1 (UR (1234, 1235)));
 101   sink (f_uint_1 (UR (1235, 1236)));   /* { dg-warning "argument 1 range \\\[\[0-9\]+u?, \[0-9\]+u?\\\] exceeds maximum object size 1234" } */
 102   sink (f_uint_1 (UR (1, max - 1)));
 103   sink (f_uint_1 (UR (1, max)));
 104 }
 105
 106 void
 107 test_int_cst (void)
 108 {
 109   const int min = INT_MIN;
 110   const int max = INT_MAX;
 111
 112   sink (f_int_1 (min));   /* { dg-warning "argument 1 value .-\[0-9\]+. is negative" } */
 113   sink (f_int_1 (-1));    /* { dg-warning "argument 1 value .-1. is negative" } */
 114   sink (f_int_1 (0));
 115   sink (f_int_1 (1));
 116   sink (f_int_1 (1233));
 117   sink (f_int_1 (1234));
 118   sink (f_int_1 (max));   /* { dg-warning "argument 1 value .\[0-9\]+u?. exceeds maximum object size 1234" } */
 119 }
 120
 121 void
 122 test_int_range (int n)
 123 {
 124   const int min = INT_MIN;
 125   const int max = INT_MAX;
 126
 127   sink (f_int_1 (n));
 128
 129   sink (f_int_1 (SR (min, 1234)));
 130   sink (f_int_1 (SR (-2, -1)));   /* { dg-warning "argument 1 range \\\[-2, -1\\\] is negative" } */
 131
 132   sink (f_int_1 (SR (1235, 2345)));  /* { dg-warning "argument 1 range \\\[1235, 2345\\\] exceeds maximum object size 1234" } */
 133   sink (f_int_1 (SR (max - 1, max)));   /* { dg-warning "argument 1 range \\\[\[0-9\]+, \[0-9\]+\\\] exceeds maximum object size 1234" } */
 134
 135   sink (f_int_1 (SAR (-1, 1)));
 136   sink (f_int_1 (SAR (-2, 12)));
 137   sink (f_int_1 (SAR (-3, 123)));
 138   sink (f_int_1 (SAR (-4, 1234)));   /* { dg-warning "argument 1 range \\\[1235, \[0-9\]+\\\] exceeds maximum object size 1234" } */
 139   sink (f_int_1 (SAR (min + 1, 1233)));
 140
 141 #if __i386__ || __x86_64__
 142   /* Avoid failures described in bug 79051.  */
 143   sink (f_int_1 (SAR (min + 2, 1235)));   /* { dg-warning "argument 1 range \\\[1236, \[0-9\]+\\\] exceeds maximum object size 1234" "" { target { i?86-*-* x86_64-*-* } } } */
 144 #endif
 145
 146   sink (f_int_1 (SAR (0, max)));   /* { dg-warning "argument 1 range \\\[-\[0-9\]*, -1\\\] is negative" } */
 147   /* The range below includes zero which would be diagnosed by
 148      -Walloc-size-zero but since all other values are negative it
 149      is diagnosed by -Walloc-size-larger-than.  */
 150   sink (f_int_1 (SAR (1, max)));   /* { dg-warning "argument 1 range \\\[-\[0-9\]*, 0\\\] is negative" } */
 151   sink (f_int_1 (SAR (2, max)));
 152 }
 153
 154 void
 155 test_size_cst (void)
 156 {
 157   const size_t max = __SIZE_MAX__;
 158
 159   sink (f_size_1 (0));
 160   sink (f_size_1 (1));
 161
 162   sink (f_size_2 (   0, 1234));
 163   sink (f_size_2 (   1, 1234));
 164   sink (f_size_2 (   2, 1234));  /* { dg-warning "product .2 \\* 1234. of arguments 1 and 2 exceeds maximum object size \[0-9\]+" } */
 165   sink (f_size_2 (1234, 1234));  /* { dg-warning "product .1234 \\* 1234. of arguments 1 and 2 exceeds (.SIZE_MAX.|maximum object size 1234)" } */
 166   sink (f_size_2 (1235, 1234));  /* { dg-warning "argument 1 value .1235. exceeds maximum object size 1234" } */
 167   sink (f_size_2 (1234, 1235));  /* { dg-warning "argument 2 value .1235. exceeds maximum object size 1234" } */
 168   sink (f_size_2 (1234, max));  /* { dg-warning "argument 2 value .\[0-9\]+. exceeds maximum object size 1234" } */
 169   sink (f_size_2 (max, 1234));  /* { dg-warning "argument 1 value .\[0-9\]+. exceeds maximum object size 1234" } */
 170 }
 171
 172 void
 173 test_size_range (size_t n)
 174 {
 175   const size_t max = __SIZE_MAX__;
 176
 177   sink (f_size_1 (n));
 178
 179   sink (f_size_1 (UR (0, 1)));
 180   sink (f_size_1 (UR (0, max - 1)));
 181   sink (f_size_1 (UR (1, max - 1)));
 182   sink (f_size_1 (UR (1, max)));
 183
 184   sink (f_size_1 (UAR (1, 1)));
 185   /* Since the only valid argument in the anti-range below is zero
 186      a warning is expected even though -Walloc-zero is not specified.  */
 187   sink (f_size_1 (UAR (1, 1234)));   /* { dg-warning "argument 1 range \\\[\[0-9\]+, \[0-9\]+\\\] exceeds maximum object size " } */
 188   /* The only valid argument in this range is 1.  */
 189   sink (f_size_1 (UAR (2, max / 2)));
 190
 191   sink (f_size_2 (n, n));
 192   sink (f_size_2 (n, 1234));
 193   sink (f_size_2 (1234, n));
 194
 195   sink (f_size_2 (UR (0, 1), 1234));
 196   sink (f_size_2 (UR (0, 1), 1235));   /* { dg-warning "argument 2 value .1235. exceeds maximum object size 1234" } */
 197
 198   sink (f_size_2 (UR (1235, 1236), n));  /* { dg-warning "argument 1 range \\\[1235, 1236\\\] exceeds maximum object size 1234" } */
 199
 200   sink (f_size_2 (UR (1235, 1236), UR (max / 2, max)));  /* { dg-warning "argument 1 range \\\[\[0-9\]+, \[0-9\]+\\\] exceeds maximum object size " } */
 201 /* { dg-warning "argument 2 range \\\[\[0-9\]+, \[0-9\]+\\\] exceeds maximum object size " "argument 2" { target *-*-* } .-1 } */
 202
 203 }