| /* { dg-add-options stack_size } */ |
| |
| /* Test for a reload bug: |
| if you have a memory reference using the indexed addressing |
| mode, and the base address is a pseudo containing an address in the frame |
| and this pseudo fails to get a hard register, we end up with a double PLUS, |
| so the frame address gets reloaded. Now, when the index got a hard register, |
| and it dies in this insn, push_reload will consider that hard register as |
| a reload register, and disregrad overlaps with rld[n_reloads].in . That is |
| fine as long as the add can be done with a single insn, but when the |
| constant is so large that it has to be reloaded into a register first, |
| that clobbers the index. */ |
| |
| #include <stdarg.h> |
| |
| #ifdef STACK_SIZE |
| /* We need to be careful that we don't blow our stack. Function f, in the |
| worst case, needs to fit on the stack: |
| |
| * 40 int[CHUNK] arrays; |
| * ~40 ints; |
| * ~40 pointers for stdarg passing. |
| |
| Subtract the last two off STACK_SIZE and figure out what the maximum |
| chunk size can be. We make the last bit conservative to account for |
| register saves and other processor-dependent saving. Limit the |
| chunk size to some sane values. */ |
| |
| #define MIN(X,Y) ((X) < (Y) ? (X) : (Y)) |
| #define MAX(X,Y) ((X) > (Y) ? (X) : (Y)) |
| |
| #define CHUNK \ |
| MIN (500, (MAX (1, (signed)(STACK_SIZE-40*sizeof(int)-256*sizeof(void *)) \ |
| / (signed)(40*sizeof(int))))) |
| #else |
| #define CHUNK 500 |
| #endif |
| |
| void s(int, ...); |
| void z(int, ...); |
| void c(int, ...); |
| |
| typedef int l[CHUNK]; |
| |
| void |
| f (int n) |
| { |
| int i; |
| l a0, a1, a2, a3, a4, a5, a6, a7, a8, a9; |
| l a10, a11, a12, a13, a14, a15, a16, a17, a18, a19; |
| l a20, a21, a22, a23, a24, a25, a26, a27, a28, a29; |
| l a30, a31, a32, a33, a34, a35, a36, a37, a38, a39; |
| int i0, i1, i2, i3, i4, i5, i6, i7, i8, i9; |
| int i10, i11, i12, i13, i14, i15, i16, i17, i18, i19; |
| int i20, i21, i22, i23, i24, i25, i26, i27, i28, i29; |
| int i30, i31, i32, i33, i34, i35, i36, i37, i38, i39; |
| |
| for (i = 0; i < n; i++) |
| { |
| s (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, |
| a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, |
| a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, |
| a30, a31, a32, a33, a34, a35, a36, a37, a38, a39); |
| i0 = a0[0]; |
| i1 = a1[0]; |
| i2 = a2[0]; |
| i3 = a3[0]; |
| i4 = a4[0]; |
| i5 = a5[0]; |
| i6 = a6[0]; |
| i7 = a7[0]; |
| i8 = a8[0]; |
| i9 = a9[0]; |
| i10 = a10[0]; |
| i11 = a11[0]; |
| i12 = a12[0]; |
| i13 = a13[0]; |
| i14 = a14[0]; |
| i15 = a15[0]; |
| i16 = a16[0]; |
| i17 = a17[0]; |
| i18 = a18[0]; |
| i19 = a19[0]; |
| i20 = a20[0]; |
| i21 = a21[0]; |
| i22 = a22[0]; |
| i23 = a23[0]; |
| i24 = a24[0]; |
| i25 = a25[0]; |
| i26 = a26[0]; |
| i27 = a27[0]; |
| i28 = a28[0]; |
| i29 = a29[0]; |
| i30 = a30[0]; |
| i31 = a31[0]; |
| i32 = a32[0]; |
| i33 = a33[0]; |
| i34 = a34[0]; |
| i35 = a35[0]; |
| i36 = a36[0]; |
| i37 = a37[0]; |
| i38 = a38[0]; |
| i39 = a39[0]; |
| z (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, |
| a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, |
| a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, |
| a30, a31, a32, a33, a34, a35, a36, a37, a38, a39); |
| a0[i0] = i0; |
| a1[i1] = i1; |
| a2[i2] = i2; |
| a3[i3] = i3; |
| a4[i4] = i4; |
| a5[i5] = i5; |
| a6[i6] = i6; |
| a7[i7] = i7; |
| a8[i8] = i8; |
| a9[i9] = i9; |
| a10[i10] = i10; |
| a11[i11] = i11; |
| a12[i12] = i12; |
| a13[i13] = i13; |
| a14[i14] = i14; |
| a15[i15] = i15; |
| a16[i16] = i16; |
| a17[i17] = i17; |
| a18[i18] = i18; |
| a19[i19] = i19; |
| a20[i20] = i20; |
| a21[i21] = i21; |
| a22[i22] = i22; |
| a23[i23] = i23; |
| a24[i24] = i24; |
| a25[i25] = i25; |
| a26[i26] = i26; |
| a27[i27] = i27; |
| a28[i28] = i28; |
| a29[i29] = i29; |
| a30[i30] = i30; |
| a31[i31] = i31; |
| a32[i32] = i32; |
| a33[i33] = i33; |
| a34[i34] = i34; |
| a35[i35] = i35; |
| a36[i36] = i36; |
| a37[i37] = i37; |
| a38[i38] = i38; |
| a39[i39] = i39; |
| c (40, a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, |
| a10, a11, a12, a13, a14, a15, a16, a17, a18, a19, |
| a20, a21, a22, a23, a24, a25, a26, a27, a28, a29, |
| a30, a31, a32, a33, a34, a35, a36, a37, a38, a39); |
| } |
| } |
| |
| int |
| main () |
| { |
| /* CHUNK needs to be at least 40 to avoid stack corruption, |
| since index variable i0 in "a[i0] = i0" equals 39. */ |
| if (CHUNK < 40) |
| exit (0); |
| |
| f (1); |
| exit (0); |
| } |
| |
| void s(int n, ...) |
| { |
| va_list list; |
| |
| va_start (list, n); |
| while (n--) |
| { |
| int *a = va_arg (list, int *); |
| a[0] = n; |
| } |
| va_end (list); |
| } |
| |
| void z(int n, ...) |
| { |
| va_list list; |
| |
| va_start (list, n); |
| while (n--) |
| { |
| int *a = va_arg (list, int *); |
| __builtin_memset (a, 0, sizeof (l)); |
| } |
| va_end (list); |
| } |
| |
| void c(int n, ...) |
| { |
| va_list list; |
| |
| va_start (list, n); |
| while (n--) |
| { |
| int *a = va_arg (list, int *); |
| if (a[n] != n) |
| abort (); |
| } |
| va_end (list); |
| } |