|
145
|
1 /* PR c/87795 - Excessive alignment permitted for functions and labels
|
|
|
2 { dg-do compile }
|
|
|
3 { dg-options "-Wno-pedantic" } */
|
|
|
4
|
|
|
5 /* The maximum alignment GCC can handle. */
|
|
|
6 #define ALIGN_MAX_HARD 0x10000000
|
|
|
7
|
|
|
8 /* Hardcode a few known values for testing the tight bounds. */
|
|
|
9 #if __hpux__ && __hppa__ && __LP64__
|
|
|
10 /* Maximum alignment for functions and objects with static storage
|
|
|
11 duration that's expected to be accepted. */
|
|
|
12 # define ALIGN_MAX_STATIC 0x1000
|
|
|
13 /* Excessive alignment for functions and objects with static storage
|
|
|
14 duration that's expected to trigger an error. */
|
|
|
15 #elif __MACH__
|
|
|
16 # define ALIGN_MAX_STATIC 0x8000
|
|
|
17 #elif pdp11
|
|
|
18 # define ALIGN_MAX_STATIC 2
|
|
|
19 /* Work around a pdp11 ICE (see PR target/87821). */
|
|
|
20 # define ALIGN_MAX_AUTO (ALIGN_MAX_HARD >> 14)
|
|
|
21 #elif __powerpc64__ || __x86_64__
|
|
|
22 /* Is this processor- or operating-system specific? */
|
|
|
23 # define ALIGN_MAX_STATIC ALIGN_MAX_HARD
|
|
|
24 #else
|
|
|
25 /* Guaranteed to be accepted regardless of the target. */
|
|
|
26 # define ALIGN_MAX_STATIC __BIGGEST_ALIGNMENT__
|
|
|
27 /* Guaranteed to be rejected regardless of the target. */
|
|
|
28 # define ALIGN_TOO_BIG_OFILE (ALIGN_MAX_HARD << 1)
|
|
|
29 #endif
|
|
|
30
|
|
|
31 /* Maximum alignment for auto objects that's expected to be accepted. */
|
|
|
32 #ifndef ALIGN_MAX_AUTO
|
|
|
33 # define ALIGN_MAX_AUTO ALIGN_MAX_HARD
|
|
|
34 #endif
|
|
|
35
|
|
|
36 #ifndef ALIGN_TOO_BIG_OFILE
|
|
|
37 # define ALIGN_TOO_BIG_OFILE (ALIGN_MAX_STATIC << 1)
|
|
|
38 #endif
|
|
|
39
|
|
|
40
|
|
|
41 #define ALIGN(N) __attribute__ ((aligned (N)))
|
|
|
42
|
|
|
43
|
|
|
44 /* Verify that types can be defined maximally overaligned using
|
|
|
45 attribute aligned. */
|
|
|
46 typedef ALIGN (ALIGN_MAX_HARD) char CharAlignedMaxHard;
|
|
|
47 typedef ALIGN (ALIGN_MAX_AUTO) char CharAlignedMaxAuto;
|
|
|
48 typedef ALIGN (ALIGN_MAX_STATIC) char CharAlignedMaxStatic;
|
|
|
49
|
|
|
50 #if ALIGN_TOO_BIG_OFILE < ALIGN_MAX_HARD
|
|
|
51 /* Also verify that an alignment greater than MAX_OFILE_ALIGNMENT
|
|
|
52 is accepted unless the constant is as large as GCC's maximum
|
|
|
53 supported alignment in any context. */
|
|
|
54 typedef ALIGN (ALIGN_TOO_BIG_OFILE) char CharAlignedTooBig;
|
|
|
55 #endif
|
|
|
56
|
|
|
57 CharAlignedMaxStatic t_max;
|
|
|
58
|
|
|
59 /* Verify that globals can be defined maximally overaligned using
|
|
|
60 attribute aligned. */
|
|
|
61 ALIGN (ALIGN_MAX_STATIC) static const char aligned_sc_max = 0;
|
|
|
62 ALIGN (ALIGN_MAX_STATIC) const char aligned_c_max = aligned_sc_max;
|
|
|
63 ALIGN (ALIGN_MAX_STATIC) char aligned_v_max;
|
|
|
64 ALIGN (ALIGN_MAX_STATIC) void aligned_f_max (void);
|
|
|
65
|
|
|
66 _Static_assert (__alignof__ (aligned_sc_max) == ALIGN_MAX_STATIC);
|
|
|
67 _Static_assert (__alignof__ (aligned_c_max) == ALIGN_MAX_STATIC);
|
|
|
68 _Static_assert (__alignof__ (aligned_v_max) == ALIGN_MAX_STATIC);
|
|
|
69 _Static_assert (__alignof__ (aligned_f_max) == ALIGN_MAX_STATIC);
|
|
|
70
|
|
|
71
|
|
|
72 /* Verify that globals can be defined maximally overaligned using
|
|
|
73 _Alignas. */
|
|
|
74 _Alignas (ALIGN_MAX_STATIC) static const char alignas_sc_max = 0;
|
|
|
75 _Alignas (ALIGN_MAX_STATIC) const char alignas_c_max = alignas_sc_max;
|
|
|
76 _Alignas (ALIGN_MAX_STATIC) char alignas_v_max;
|
|
|
77
|
|
|
78 _Static_assert (__alignof__ (alignas_sc_max) == ALIGN_MAX_STATIC);
|
|
|
79 _Static_assert (__alignof__ (alignas_c_max) == ALIGN_MAX_STATIC);
|
|
|
80 _Static_assert (__alignof__ (alignas_v_max) == ALIGN_MAX_STATIC);
|
|
|
81
|
|
|
82
|
|
|
83 /* Verify that auto and static local variables can be defined maximally
|
|
|
84 overaligned. */
|
|
|
85
|
|
|
86 int accept_local_attribute_aligned (void)
|
|
|
87 {
|
|
|
88 #if ALIGN_TOO_BIG_OFILE < ALIGN_MAX_HARD
|
|
|
89 /* Same as above. */
|
|
|
90 typedef ALIGN (ALIGN_TOO_BIG_OFILE) char LocalCharAlignedTooBig;
|
|
|
91 LocalCharAlignedTooBig aligned_lt_too_big = 0;
|
|
|
92 (void)&aligned_lt_too_big;
|
|
|
93 #endif
|
|
|
94
|
|
|
95 static CharAlignedMaxStatic aligned_st_max;
|
|
|
96 _Static_assert (_Alignof (aligned_st_max) == ALIGN_MAX_STATIC);
|
|
|
97
|
|
|
98 CharAlignedMaxAuto aligned_t_max;
|
|
|
99 _Static_assert (_Alignof (aligned_t_max) == ALIGN_MAX_AUTO);
|
|
|
100
|
|
|
101 ALIGN (ALIGN_MAX_STATIC) char aligned_s_max;
|
|
|
102 _Static_assert (_Alignof (aligned_s_max) == ALIGN_MAX_STATIC);
|
|
|
103
|
|
|
104 ALIGN (ALIGN_MAX_AUTO) char aligned_l_max;
|
|
|
105 _Static_assert (_Alignof (aligned_l_max) == ALIGN_MAX_AUTO);
|
|
|
106
|
|
|
107 return aligned_st_max++ + aligned_t_max++ + aligned_s_max++ + aligned_l_max++;
|
|
|
108 }
|
|
|
109
|
|
|
110
|
|
|
111 int accept_local_alignas (void)
|
|
|
112 {
|
|
|
113 _Alignas (ALIGN_MAX_STATIC) char alignas_s_max;
|
|
|
114 _Static_assert (_Alignof (alignas_s_max) == ALIGN_MAX_STATIC);
|
|
|
115
|
|
|
116 _Alignas (ALIGN_MAX_AUTO) char alignas_l_max;
|
|
|
117 _Static_assert (_Alignof (alignas_l_max) == ALIGN_MAX_AUTO);
|
|
|
118
|
|
|
119 return alignas_s_max++ + alignas_l_max++;
|
|
|
120 }
|
|
|
121
|
|
|
122
|
|
|
123 /* Verify that auto and static local variables are subject to the object
|
|
|
124 file alignment limit. The "object file" part may not be mentioned if
|
|
|
125 the object file maximum is the same as GCC's internal maximum. */
|
|
|
126
|
|
|
127 int reject_local_align (void)
|
|
|
128 {
|
|
|
129 /* Ironically, the errors below are on different lines for each
|
|
|
130 of the two declarations if the aligned attribute is on a line
|
|
|
131 of its own. */
|
|
|
132 ALIGN (ALIGN_TOO_BIG_OFILE) static char aligned_sl_max; /* { dg-error "requested alignment .\[0-9\]+. exceeds\( object file\)* maximum \[0-9\]+" } */
|
|
|
133
|
|
|
134 _Alignas (ALIGN_TOO_BIG_OFILE) static char alignas_sl_max; /* { dg-error "alignment" } */
|
|
|
135
|
|
|
136 return aligned_sl_max++ + alignas_sl_max++;
|
|
|
137 }
|
|
|
138
|
|
|
139
|
|
|
140 /* Verify that global variables are subject to the object file
|
|
|
141 alignment limit. */
|
|
|
142
|
|
|
143 ALIGN (ALIGN_TOO_BIG_OFILE) char a_max_x_2; /* { dg-error "requested alignment .\[0-9\]+. exceeds\( object file\)* maximum \[0-9\]+" } */
|
|
|
144
|
|
|
145 _Alignas (ALIGN_TOO_BIG_OFILE) char a_max_x_2; /* { dg-error "alignment" } */
|
|
|
146
|
|
|
147 ALIGN (ALIGN_TOO_BIG_OFILE) void f_max_x_2 (void); /* { dg-error "requested alignment .\[0-9\]+. exceeds\( object file\)* maximum \[0-9\]+" } */
|
