modernc.org/ccgo/v3@v3.16.14/lib/testdata/gcc-9.1.0/gcc/testsuite/gcc.c-torture/execute/multi-ix.c (about)

     1  /* { dg-add-options stack_size } */
     2  
     3  /* Test for a reload bug:
     4     if you have a memory reference using the indexed addressing
     5     mode, and the base address is a pseudo containing an address in the frame
     6     and this pseudo fails to get a hard register, we end up with a double PLUS,
     7     so the frame address gets reloaded.  Now, when the index got a hard register,
     8     and it dies in this insn, push_reload will consider that hard register as
     9     a reload register, and disregrad overlaps with rld[n_reloads].in .  That is
    10     fine as long as the add can be done with a single insn, but when the
    11     constant is so large that it has to be reloaded into a register first,
    12     that clobbers the index.  */
    13  
    14  #include <stdarg.h>
    15  
    16  #ifdef STACK_SIZE
    17  /* We need to be careful that we don't blow our stack.  Function f, in the
    18     worst case, needs to fit on the stack:
    19  
    20     * 40 int[CHUNK] arrays;
    21     * ~40 ints;
    22     * ~40 pointers for stdarg passing.
    23  
    24     Subtract the last two off STACK_SIZE and figure out what the maximum
    25     chunk size can be.  We make the last bit conservative to account for
    26     register saves and other processor-dependent saving.  Limit the
    27     chunk size to some sane values.  */
    28  
    29  #define MIN(X,Y) ((X) < (Y) ? (X) : (Y))
    30  #define MAX(X,Y) ((X) > (Y) ? (X) : (Y))
    31  
    32  #define CHUNK								\
    33    MIN (500, (MAX (1, (signed)(STACK_SIZE-40*sizeof(int)-256*sizeof(void *)) \
    34  		      / (signed)(40*sizeof(int)))))
    35  #else
    36  #define CHUNK 500
    37  #endif
    38  
    39  void s(int, ...);
    40  void z(int, ...);
    41  void c(int, ...);
    42  
    43  typedef int l[CHUNK];
    44  
    45  void
    46  f (int n)
    47  {
    48    int i;
    49    l a0, a1, a2, a3, a4, a5, a6, a7, a8, a9;
    50    l a10, a11, a12, a13, a14, a15, a16, a17, a18, a19;
    51    l a20, a21, a22, a23, a24, a25, a26, a27, a28, a29;
    52    l a30, a31, a32, a33, a34, a35, a36, a37, a38, a39;
    53    int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9;
    54    int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19;
    55    int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29;
    56    int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39;
    57  
    58    for (i = 0; i < n; i++)
    59      {
    60        s (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
    61  	 a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,
    62           a20, a21, a22, a23, a24, a25, a26, a27, a28, a29,
    63           a30, a31, a32, a33, a34, a35, a36, a37, a38, a39);
    64        i0 = a0[0];
    65        i1 = a1[0];
    66        i2 = a2[0];
    67        i3 = a3[0];
    68        i4 = a4[0];
    69        i5 = a5[0];
    70        i6 = a6[0];
    71        i7 = a7[0];
    72        i8 = a8[0];
    73        i9 = a9[0];
    74        i10 = a10[0];
    75        i11 = a11[0];
    76        i12 = a12[0];
    77        i13 = a13[0];
    78        i14 = a14[0];
    79        i15 = a15[0];
    80        i16 = a16[0];
    81        i17 = a17[0];
    82        i18 = a18[0];
    83        i19 = a19[0];
    84        i20 = a20[0];
    85        i21 = a21[0];
    86        i22 = a22[0];
    87        i23 = a23[0];
    88        i24 = a24[0];
    89        i25 = a25[0];
    90        i26 = a26[0];
    91        i27 = a27[0];
    92        i28 = a28[0];
    93        i29 = a29[0];
    94        i30 = a30[0];
    95        i31 = a31[0];
    96        i32 = a32[0];
    97        i33 = a33[0];
    98        i34 = a34[0];
    99        i35 = a35[0];
   100        i36 = a36[0];
   101        i37 = a37[0];
   102        i38 = a38[0];
   103        i39 = a39[0];
   104        z (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
   105  	 a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,
   106           a20, a21, a22, a23, a24, a25, a26, a27, a28, a29,
   107           a30, a31, a32, a33, a34, a35, a36, a37, a38, a39);
   108        a0[i0] = i0;
   109        a1[i1] = i1;
   110        a2[i2] = i2;
   111        a3[i3] = i3;
   112        a4[i4] = i4;
   113        a5[i5] = i5;
   114        a6[i6] = i6;
   115        a7[i7] = i7;
   116        a8[i8] = i8;
   117        a9[i9] = i9;
   118        a10[i10] = i10;
   119        a11[i11] = i11;
   120        a12[i12] = i12;
   121        a13[i13] = i13;
   122        a14[i14] = i14;
   123        a15[i15] = i15;
   124        a16[i16] = i16;
   125        a17[i17] = i17;
   126        a18[i18] = i18;
   127        a19[i19] = i19;
   128        a20[i20] = i20;
   129        a21[i21] = i21;
   130        a22[i22] = i22;
   131        a23[i23] = i23;
   132        a24[i24] = i24;
   133        a25[i25] = i25;
   134        a26[i26] = i26;
   135        a27[i27] = i27;
   136        a28[i28] = i28;
   137        a29[i29] = i29;
   138        a30[i30] = i30;
   139        a31[i31] = i31;
   140        a32[i32] = i32;
   141        a33[i33] = i33;
   142        a34[i34] = i34;
   143        a35[i35] = i35;
   144        a36[i36] = i36;
   145        a37[i37] = i37;
   146        a38[i38] = i38;
   147        a39[i39] = i39;
   148        c (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9,
   149  	 a10, a11, a12, a13, a14, a15, a16, a17, a18, a19,
   150           a20, a21, a22, a23, a24, a25, a26, a27, a28, a29,
   151           a30, a31, a32, a33, a34, a35, a36, a37, a38, a39);
   152      }
   153  }
   154  
   155  int
   156  main ()
   157  {
   158    /* CHUNK needs to be at least 40 to avoid stack corruption,
   159       since index variable i0 in "a[i0] = i0" equals 39.  */
   160    if (CHUNK < 40)
   161      exit (0);
   162  
   163    f (1);
   164    exit (0);
   165  }
   166  
   167  void s(int n, ...)
   168  {
   169    va_list list;
   170  
   171    va_start (list, n);
   172    while (n--)
   173      {
   174        int *a = va_arg (list, int *);
   175        a[0] = n;
   176      }
   177    va_end (list);
   178  }
   179  
   180  void z(int n, ...)
   181  {
   182    va_list list;
   183  
   184    va_start (list, n);
   185    while (n--)
   186      {
   187        int *a = va_arg (list, int *);
   188        __builtin_memset (a, 0, sizeof (l));
   189      }
   190    va_end (list);
   191  }
   192  
   193  void c(int n, ...)
   194  {
   195    va_list list;
   196  
   197    va_start (list, n);
   198    while (n--)
   199      {
   200        int *a = va_arg (list, int *);
   201        if (a[n] != n)
   202  	abort ();
   203      }
   204    va_end (list);
   205  }