1  /* To test that the compiler can fill all the paddings to zeroes for the 
       2     structures when the auto variable is partially initialized,  fully 
       3     initialized, or not initialized for -ftrivial-auto-var-init=pattern.  */
       4  /* { dg-do run } */
       5  /* { dg-options "-ftrivial-auto-var-init=pattern" } */
       6  
       7  /* Structure with no padding. */
       8  struct test_packed {
       9    unsigned long one;
      10    unsigned long two;
      11    unsigned long three;
      12    unsigned long four;
      13  } p1;
      14  
      15  /* Simple structure with padding likely to be covered by compiler. */
      16  struct test_small_hole {
      17    unsigned long one;
      18    char two;
      19    /* 3 byte padding hole here. */
      20    int three;
      21    unsigned long four;
      22  } sh1;
      23  
      24  /* Try to trigger unhandled padding in a structure. */
      25  struct test_aligned {
      26    unsigned int internal1;
      27    unsigned long long internal2;
      28  } __attribute__((__aligned__(64)));
      29  
      30  struct test_aligned a1;
      31  
      32  struct test_big_hole {
      33    unsigned char one;
      34    unsigned char two;
      35    unsigned char three;
      36    /* 61 byte padding hole here. */
      37    struct test_aligned four;
      38  } __attribute__((__aligned__(64))); 
      39  
      40  struct test_big_hole bh1;
      41  
      42  struct test_trailing_hole {
      43    char *one;
      44    char *two;
      45    char *three;
      46    char four;
      47    /* "sizeof(unsigned long) - 1" byte padding hole here. */
      48  } th1;
      49  
      50  __attribute__((noipa)) void
      51  foo (struct test_packed *p, struct test_small_hole *sh, struct test_aligned *a,
      52       struct test_big_hole *bh, struct test_trailing_hole *th)
      53  {
      54    p->one = 1; p->two = 2; p->three = 3; p->four = 4;
      55    sh->one = 11; sh->two = 12; sh->three = 13; sh->four = 14;
      56    a->internal1 = 21; a->internal2 = 22;
      57    bh->one = 31; bh->two = 32; bh->three = 33;
      58    bh->four.internal1 = 34; bh->four.internal2 = 35; 
      59    th->one = 0; th->two = 0; th->three = 0; th->four = 44;
      60  }
      61  
      62  int main ()
      63  {
      64    struct test_packed p2;
      65    struct test_small_hole sh2;
      66    struct test_aligned a2;
      67    struct test_big_hole bh2;
      68    struct test_trailing_hole th2;
      69  
      70    struct test_packed p3 = {.one = 1};
      71    struct test_small_hole sh3 = {.two = 12};
      72    struct test_aligned a3 = {.internal1 = 21};
      73    struct test_big_hole bh3 = {.one = 31};
      74    struct test_trailing_hole th3 = {.three = 0};
      75  
      76    struct test_packed p4 = {.one = 1, .two = 2, .three = 3, .four = 4};
      77    struct test_small_hole sh4 = {.one = 11, .two = 12, .three = 13, .four = 14};
      78    struct test_aligned a4 = {.internal1 = 21, .internal2 = 22};
      79    struct test_big_hole bh4 = {.one = 31, .two = 32, .three = 33};
      80    struct test_trailing_hole th4 = {.one = 0, .two = 0, .three = 0, .four = 44};
      81  
      82    foo (&p1, &sh1, &a1, &bh1, &th1);
      83    foo (&p2, &sh2, &a2, &bh2, &th2);
      84    foo (&p3, &sh3, &a3, &bh3, &th3);
      85    bh4.four.internal1 = 34; bh4.four.internal2 = 35;
      86  
      87    __builtin_clear_padding (&p1);
      88    __builtin_clear_padding (&sh1);
      89    __builtin_clear_padding (&a1);
      90    __builtin_clear_padding (&bh1);
      91    __builtin_clear_padding (&th1);
      92  
      93    if (__builtin_memcmp (&p1, &p2, sizeof (p1))
      94        || __builtin_memcmp (&sh1, &sh2, sizeof (sh1))
      95        || __builtin_memcmp (&a1, &a2, sizeof (a1))
      96        || __builtin_memcmp (&bh1, &bh2, sizeof (bh1))
      97        || __builtin_memcmp (&th1, &th2, sizeof (th1)))
      98      __builtin_abort ();
      99    if (__builtin_memcmp (&p1, &p3, sizeof (p1))
     100        || __builtin_memcmp (&sh1, &sh3, sizeof (sh1))
     101        || __builtin_memcmp (&a1, &a3, sizeof (a1))
     102        || __builtin_memcmp (&bh1, &bh3, sizeof (bh1))
     103        || __builtin_memcmp (&th1, &th3, sizeof (th1)))
     104      __builtin_abort ();
     105    if (__builtin_memcmp (&p1, &p4, sizeof (p1))
     106        || __builtin_memcmp (&sh1, &sh4, sizeof (sh1))
     107        || __builtin_memcmp (&a1, &a4, sizeof (a1))
     108        || __builtin_memcmp (&bh1, &bh4, sizeof (bh1))
     109        || __builtin_memcmp (&th1, &th4, sizeof (th1)))
     110      __builtin_abort ();
     111  
     112  
     113    return 0;
     114  }