| 1 |
/* Verify __builtin_has_attribute return value for types. |
| 2 |
{ dg-do compile } |
| 3 |
{ dg-options "-Wall -ftrack-macro-expansion=0" } |
| 4 |
{ dg-options "-Wall -Wno-narrowing -Wno-unused-local-typedefs -ftrack-macro-expansion=0" { target c++ } } */ |
| 5 |
|
| 6 |
#define ATTR(...) __attribute__ ((__VA_ARGS__)) |
| 7 |
|
| 8 |
#define A(expect, sym, attr) \ |
| 9 |
typedef int Assert [1 - 2 * !(__builtin_has_attribute (sym, attr) == expect)] |
| 10 |
|
| 11 |
struct ATTR (packed) Packed { char c; int i; }; |
| 12 |
|
| 13 |
void fvoid (void); |
| 14 |
struct Packed fpacked (void); |
| 15 |
|
| 16 |
union OrdinaryUnion { void *p; int i; }; |
| 17 |
union ATTR (transparent_union) TransparentUnion { void *p; int i; }; |
| 18 |
|
| 19 |
/* Exercise __builtin_has_attribute with the first argument that |
| 20 |
is a type. */ |
| 21 |
|
| 22 |
void test_type (int n) |
| 23 |
{ |
| 24 |
/* Verify both forms of the attribute spelling. Unlike the attribute |
| 25 |
keyword that can be spelled three ways (with either leading or |
| 26 |
trailing underscores, or with both), attribute names can only be |
| 27 |
spelled two ways. */ |
| 28 |
A (0, int, aligned); |
| 29 |
A (0, int, __aligned__); |
| 30 |
|
| 31 |
A (0, int, aligned (1)); |
| 32 |
A (0, int, aligned (2)); |
| 33 |
A (0, int[1], aligned); |
| 34 |
A (0, int[1], aligned (2)); |
| 35 |
A (0, int[n], aligned); |
| 36 |
A (0, int[n], aligned (4)); |
| 37 |
|
| 38 |
/* Again, verify both forms of the attribute spelling. */ |
| 39 |
A (1, ATTR (aligned) char, aligned); |
| 40 |
A (1, ATTR (aligned (2)) short, aligned); |
| 41 |
A (1, ATTR (aligned (4)) int, __aligned__); |
| 42 |
|
| 43 |
A (0, int ATTR (aligned (4)), aligned (2)); |
| 44 |
A (0, int ATTR (aligned (2)), aligned (4)); |
| 45 |
/* GCC retains both attributes when the type is defined in the builtin. */ |
| 46 |
A (1, int ATTR (aligned (2), aligned (4)), aligned (2)); |
| 47 |
A (1, int ATTR (aligned (2), aligned (4)), aligned (4)); |
| 48 |
/* The following fails due to bug 87524. |
| 49 |
A (1, int ATTR (aligned (4), aligned (2))), aligned (4)); */ |
| 50 |
A (0, int ATTR (aligned (4), aligned (2)), aligned (8)); |
| 51 |
|
| 52 |
A (1, int ATTR (aligned (8)), aligned (1 + 7)); |
| 53 |
|
| 54 |
enum { eight = 8 }; |
| 55 |
A (1, int ATTR (aligned (8)), aligned (eight)); |
| 56 |
A (1, int ATTR (aligned (eight)), aligned (1 + 7)); |
| 57 |
|
| 58 |
struct NotPacked { char c; int i; }; |
| 59 |
A (0, struct NotPacked, packed); |
| 60 |
A (1, struct Packed, packed); |
| 61 |
|
| 62 |
/* Exercise types returned from a function. */ |
| 63 |
A (0, fvoid (), packed); |
| 64 |
A (1, fpacked (), packed); |
| 65 |
|
| 66 |
struct ATTR (aligned (2), packed) Aligned2Packed { char c; int i; }; |
| 67 |
A (1, struct Aligned2Packed, aligned); |
| 68 |
A (1, struct Aligned2Packed, aligned (2)); |
| 69 |
A (0, struct Aligned2Packed, aligned (4)); |
| 70 |
A (1, struct Aligned2Packed, packed); |
| 71 |
|
| 72 |
A (0, int, may_alias); |
| 73 |
A (1, ATTR (may_alias) int, may_alias); |
| 74 |
|
| 75 |
A (0, char, warn_if_not_aligned (1)); |
| 76 |
A (0, char, warn_if_not_aligned (2)); |
| 77 |
|
| 78 |
A (1, ATTR (warn_if_not_aligned (2)) char, warn_if_not_aligned); |
| 79 |
A (0, ATTR (warn_if_not_aligned (2)) char, warn_if_not_aligned (1)); |
| 80 |
A (1, ATTR (warn_if_not_aligned (2)) char, warn_if_not_aligned (2)); |
| 81 |
A (0, ATTR (warn_if_not_aligned (2)) char, warn_if_not_aligned (4)); |
| 82 |
|
| 83 |
A (0, union OrdinaryUnion, transparent_union); |
| 84 |
|
| 85 |
A (1, union TransparentUnion, transparent_union); |
| 86 |
A (1, const union TransparentUnion, transparent_union); |
| 87 |
} |
| 88 |
|
| 89 |
/* Exercise __builtin_has_attribute with the first argument that |
| 90 |
is a typedef. */ |
| 91 |
|
| 92 |
void test_typedef (int n) |
| 93 |
{ |
| 94 |
typedef char A1[1]; |
| 95 |
A (0, A1, aligned); |
| 96 |
A (0, A1, aligned (1)); |
| 97 |
A (0, A1, aligned (2)); |
| 98 |
|
| 99 |
typedef char An[n]; |
| 100 |
A (0, An, aligned); |
| 101 |
A (0, An, aligned (1)); |
| 102 |
A (0, An, aligned (2)); |
| 103 |
|
| 104 |
typedef ATTR (aligned (8)) short AI8; |
| 105 |
A (1, AI8, aligned); |
| 106 |
A (0, AI8, aligned (4)); |
| 107 |
A (1, AI8, aligned (8)); |
| 108 |
A (0, AI8, aligned (16)); |
| 109 |
|
| 110 |
A (1, const AI8, aligned); |
| 111 |
A (1, const volatile AI8, aligned); |
| 112 |
|
| 113 |
typedef ATTR (aligned (2), aligned (8), aligned (16)) int AI16; |
| 114 |
A (1, AI16, aligned); |
| 115 |
A (0, AI16, aligned (1)); |
| 116 |
A (0, AI16, aligned (2)); |
| 117 |
A (0, AI16, aligned (4)); |
| 118 |
A (0, AI16, aligned (8)); |
| 119 |
A (1, AI16, aligned (16)); |
| 120 |
A (0, AI16, aligned (32)); |
| 121 |
|
| 122 |
typedef const AI16 CAI16; |
| 123 |
A (1, CAI16, aligned); |
| 124 |
A (0, CAI16, aligned (1)); |
| 125 |
A (1, CAI16, aligned (16)); |
| 126 |
|
| 127 |
typedef int I; |
| 128 |
A (0, I, may_alias); |
| 129 |
A (0, AI8, may_alias); |
| 130 |
|
| 131 |
typedef ATTR (may_alias) int MAI; |
| 132 |
A (1, MAI, may_alias); |
| 133 |
|
| 134 |
typedef ATTR (aligned (4), may_alias) char A4MAC; |
| 135 |
A (0, A4MAC, aligned (0)); /* { dg-warning "requested alignment .0. is not a positive power of 2" } */ |
| 136 |
A (0, A4MAC, aligned (1)); |
| 137 |
A (0, A4MAC, aligned (2)); |
| 138 |
A (1, A4MAC, aligned (4)); |
| 139 |
A (0, A4MAC, aligned (8)); |
| 140 |
A (1, A4MAC, may_alias); |
| 141 |
|
| 142 |
typedef ATTR (may_alias, aligned (8)) char A8MAC; |
| 143 |
A (1, A8MAC, aligned); |
| 144 |
A (0, A8MAC, aligned (0)); /* { dg-warning "requested alignment .0. is not a positive power of 2" } */ |
| 145 |
A (0, A8MAC, aligned (1)); |
| 146 |
A (0, A8MAC, aligned (2)); |
| 147 |
A (0, A8MAC, aligned (4)); |
| 148 |
A (1, A8MAC, aligned (8)); |
| 149 |
A (0, A8MAC, aligned (16)); |
| 150 |
A (1, A8MAC, may_alias); |
| 151 |
|
| 152 |
typedef ATTR (may_alias) const AI8 CMAI8; |
| 153 |
A (1, CMAI8, aligned); |
| 154 |
A (1, CMAI8, may_alias); |
| 155 |
A (0, CMAI8, aligned (4)); |
| 156 |
A (1, CMAI8, aligned (8)); |
| 157 |
|
| 158 |
typedef void Fnull (void*, void*, void*); |
| 159 |
A (0, Fnull, nonnull); |
| 160 |
A (0, Fnull, nonnull (1)); |
| 161 |
A (0, Fnull, nonnull (2)); |
| 162 |
A (0, Fnull, nonnull (3)); |
| 163 |
|
| 164 |
typedef ATTR (nonnull) Fnull Fnonnull; |
| 165 |
A (1, Fnonnull, nonnull); |
| 166 |
A (1, Fnonnull, nonnull (1)); |
| 167 |
A (1, Fnonnull, nonnull (2)); |
| 168 |
A (1, Fnonnull, nonnull (3)); |
| 169 |
|
| 170 |
typedef ATTR (nonnull (2)) void Fnonnull_2 (void*, void*, void*); |
| 171 |
A (0, Fnonnull_2, nonnull); |
| 172 |
A (0, Fnonnull_2, nonnull (1)); |
| 173 |
A (1, Fnonnull_2, nonnull (2)); |
| 174 |
A (0, Fnonnull_2, nonnull (3)); |
| 175 |
|
| 176 |
typedef ATTR (nonnull (1), nonnull (2), nonnull (3)) |
| 177 |
void Fnonnull_1_2_3 (void*, void*, void*); |
| 178 |
|
| 179 |
/* The following fails because the built-in doesn't recognize that |
| 180 |
a single nonnull with no arguments is the same as one nonnull for |
| 181 |
each function parameter. Disable the testing for now. |
| 182 |
A (1, Fnonnull_1_2_3, nonnull); |
| 183 |
*/ |
| 184 |
A (1, Fnonnull_1_2_3, nonnull (1)); |
| 185 |
A (1, Fnonnull_1_2_3, nonnull (2)); |
| 186 |
A (1, Fnonnull_1_2_3, nonnull (3)); |
| 187 |
|
| 188 |
typedef void Freturns (void); |
| 189 |
A (0, Fnull, noreturn); |
| 190 |
A (0, Freturns, noreturn); |
| 191 |
|
| 192 |
typedef ATTR (warn_if_not_aligned (8)) char CWA8; |
| 193 |
A (0, CWA8, warn_if_not_aligned (2)); |
| 194 |
A (0, CWA8, warn_if_not_aligned (4)); |
| 195 |
A (1, CWA8, warn_if_not_aligned (8)); |
| 196 |
A (0, CWA8, warn_if_not_aligned (16)); |
| 197 |
|
| 198 |
typedef union OrdinaryUnion OrdUnion; |
| 199 |
A (0, OrdUnion, transparent_union); |
| 200 |
|
| 201 |
/* The attribute is ignored on typedefs but GCC fails to diagnose |
| 202 |
it (see bug ). */ |
| 203 |
typedef union ATTR (transparent_union) |
| 204 |
OrdinaryUnion TransUnion; /* { dg-warning "\\\[-Wattributes" "pr87578" { xfail { ! { c++ } } } } */ |
| 205 |
A (0, TransUnion, transparent_union); |
| 206 |
} |