1  /* Test that stack protection is done on chosen functions. */
       2  
       3  /* { dg-do compile { target i?86-*-* x86_64-*-* rs6000-*-* s390x-*-* } } */
       4  /* { dg-options "-O2 -fstack-protector-strong" } */
       5  
       6  /* This test checks the presence of __stack_chk_fail function in assembler.
       7   * Compiler generates _stack_chk_fail_local (wrapper) calls instead for PIC.
       8   */
       9  /* { dg-require-effective-target nonpic } */
      10  
      11  #include<string.h>
      12  
      13  extern int g0;
      14  extern int* pg0;
      15  int
      16  goo (int *);
      17  int
      18  hoo (int);
      19  
      20  /* Function frame address escaped function call. */
      21  int
      22  foo1 ()
      23  {
      24    int i;
      25    return goo (&i);
      26  }
      27  
      28  struct ArrayStruct
      29  {
      30    int a;
      31    int array[10];
      32  };
      33  
      34  struct AA
      35  {
      36    int b;
      37    struct ArrayStruct as;
      38  };
      39  
      40  /* Function frame contains array. */
      41  int
      42  foo2 ()
      43  {
      44    struct AA aa;
      45    int i;
      46    for (i = 0; i < 10; ++i)
      47      {
      48        aa.as.array[i] = i * (i-1) + i / 2;
      49      }
      50    return aa.as.array[5];
      51  }
      52  
      53  /* Address computation based on a function frame address. */
      54  int
      55  foo3 ()
      56  {
      57    int a;
      58    int *p;
      59    p = &a + 5;
      60    return goo (p);
      61  }
      62  
      63  /* Address cast based on a function frame address. */
      64  int
      65  foo4 ()
      66  {
      67    int a;
      68    return goo (g0 << 2 ? (int *)(3 * (long)(void *)(&a)) : 0);
      69  }
      70  
      71  /* Address cast based on a local array. */
      72  int
      73  foo5 ()
      74  {
      75    short array[10];
      76    return goo ((int *)(array + 5));
      77  }
      78  
      79  struct BB
      80  {
      81    int one;
      82    int two;
      83    int three;
      84  };
      85  
      86  /* Address computaton based on a function frame address.*/
      87  int
      88  foo6 ()
      89  {
      90    struct BB bb;
      91    return goo (&bb.one + sizeof(int));
      92  }
      93  
      94  /* Function frame address escaped via global variable. */
      95  int
      96  foo7 ()
      97  {
      98    int a;
      99    pg0 = &a;
     100    goo (pg0);
     101    return *pg0;
     102  }
     103  
     104  /* Check that this covers -fstack-protector. */
     105  int
     106  foo8 ()
     107  {
     108    char base[100];
     109    memcpy ((void *)base, (const void *)pg0, 105);   /* { dg-warning "writing 105 bytes into a region of size 100" } */
     110    return (int)(base[32]);
     111  }
     112  
     113  /* Check that this covers -fstack-protector. */
     114  int
     115  foo9 ()
     116  {
     117    char* p = __builtin_alloca (100);
     118    return goo ((int *)(p + 50));
     119  }
     120  
     121  int
     122  global2 (struct BB* pbb);
     123  
     124  /* Address taken on struct. */
     125  int
     126  foo10 ()
     127  {
     128    struct BB bb;
     129    int i;
     130    bb.one = global2 (&bb);
     131    for (i = 0; i < 10; ++i)
     132      {
     133        bb.two = bb.one + bb.two;
     134        bb.three = bb.one + bb.two + bb.three;
     135      }
     136    return bb.three;
     137  }
     138  
     139  struct B
     140  {
     141    /* Discourage passing this struct in registers. */
     142    int a1, a2, a3, a4, a5, a6, a7, a8, a9, a10;
     143  };
     144  
     145  struct B global3 (void);
     146  
     147  int foo11 ()
     148  {
     149    return global3 ().a1;
     150  }
     151  
     152  void foo12 ()
     153  {
     154    global3 ();
     155  }
     156  
     157  /* { dg-final { scan-assembler-times "stack_chk_fail" 12 } } */