1  /* { dg-do compile } */
       2  /* { dg-require-effective-target stdint_types } */
       3  /* { dg-require-effective-target alloca } */
       4  /* { dg-options "-O2 -Wvla-larger-than=40" } */
       5  
       6  #include <stdint.h>
       7  
       8  void f0 (void *);
       9  void
      10  f1 (__SIZE_TYPE__ a)
      11  {
      12    if (a <= 10)
      13      {
      14        // 10 * 4 bytes = 40: OK!
      15        uint32_t x[a];
      16        f0 (x);
      17      }
      18  }
      19  
      20  void
      21  f2 (__SIZE_TYPE__ a)
      22  {
      23    if (a <= 11)
      24      {
      25        // 11 * 4 bytes = 44: Not OK.
      26        uint32_t x[a]; // { dg-warning "array may be too large" }
      27        f0 (x);
      28      }
      29  }
      30  
      31  void
      32  f3 (__SIZE_TYPE__ a, __SIZE_TYPE__ b)
      33  {
      34    if (a <= 5 && b <= 3)
      35      {
      36        // 5 * 3 * 4 bytes = 60: Not OK.
      37        uint32_t x[a][b]; // { dg-warning "array may be too large" }
      38        f0 (x);
      39      }
      40  }
      41  
      42  void
      43  f4 (__SIZE_TYPE__ a, __SIZE_TYPE__ b)
      44  {
      45    if (a <= 5 && b <= 2)
      46      {
      47        // 5 * 2 * 4 bytes = 40 bytes: OK!
      48        uint32_t x[a][b];
      49        f0 (x);
      50      }
      51  }
      52  
      53  void
      54  f5 (__SIZE_TYPE__ len)
      55  {
      56    // Test that a direct call to __builtin_alloca_with_align is not
      57    // confused with a VLA.
      58    void *p = __builtin_alloca_with_align (len, 8);
      59    f0 (p);
      60  }
      61  
      62  void
      63  f6 (unsigned stuff)
      64  {
      65    int n = 7000;
      66    do {
      67      char a[n]; // { dg-warning "variable-length array is too large" }
      68      f0 (a);
      69    } while (stuff--);
      70  }