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