gcc/testsuite/gcc.c-torture/execute/multi-ix.c

   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 }