| 1 |
/* Verify __builtin_has_attribute return value for functions. |
| 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 |
{ dg-additional-options "-DSKIP_ALIAS" { target { { *-*-darwin* hppa*-*-hpux } || { ! alias } } } } |
| 6 |
*/ |
| 7 |
|
| 8 |
#define ATTR(...) __attribute__ ((__VA_ARGS__)) |
| 9 |
|
| 10 |
void fnone (void); |
| 11 |
|
| 12 |
ATTR (aligned) void faligned (void); |
| 13 |
ATTR (aligned (1)) void faligned_1 (void); |
| 14 |
ATTR (aligned (2)) void faligned_2 (void); |
| 15 |
ATTR (aligned (4)) void faligned_4 (void); |
| 16 |
ATTR (aligned (8)) void faligned_8 (void); |
| 17 |
|
| 18 |
ATTR (alloc_size (1)) void* falloc_size_1 (int, int); |
| 19 |
ATTR (alloc_size (2)) void* falloc_size_2 (int, int); |
| 20 |
ATTR (alloc_size (2, 4)) void* falloc_size_2_4 (int, int, int, int); |
| 21 |
|
| 22 |
ATTR (alloc_align (1)) void* falloc_align_1 (int, int); |
| 23 |
ATTR (alloc_align (2)) void* falloc_align_2 (int, int); |
| 24 |
ATTR (alloc_align (1), alloc_size (2)) void* falloc_align_1_size_2 (int, int); |
| 25 |
ATTR (alloc_align (2), alloc_size (1)) void* falloc_align_2_size_1 (int, int); |
| 26 |
|
| 27 |
#if __cplusplus |
| 28 |
extern "C" |
| 29 |
#endif |
| 30 |
ATTR (noreturn) void fnoreturn (void) { __builtin_abort (); } |
| 31 |
|
| 32 |
#ifndef SKIP_ALIAS |
| 33 |
ATTR (alias ("fnoreturn")) void falias (void); |
| 34 |
#endif |
| 35 |
|
| 36 |
#define A(expect, sym, attr) \ |
| 37 |
typedef int Assert [1 - 2 * !(__builtin_has_attribute (sym, attr) == expect)] |
| 38 |
|
| 39 |
void test_aligned (void) |
| 40 |
{ |
| 41 |
A (0, fnone, aligned); |
| 42 |
A (0, fnone, aligned (0)); /* { dg-warning "requested alignment .0. is not a positive power of 2" } */ |
| 43 |
A (0, fnone, aligned (1)); |
| 44 |
A (0, fnone, aligned (2)); |
| 45 |
A (0, fnone, aligned (4)); |
| 46 |
A (0, fnone, aligned (8)); |
| 47 |
A (0, fnone, aligned (16)); |
| 48 |
|
| 49 |
A (1, faligned, aligned); |
| 50 |
A (0, faligned, aligned (0)); /* { dg-warning "requested alignment .0. is not a positive power of 2" } */ |
| 51 |
A (0, faligned, aligned (1)); |
| 52 |
A (0, faligned, aligned (2)); |
| 53 |
|
| 54 |
A (1, faligned_1, aligned); |
| 55 |
A (0, faligned_1, aligned (0)); /* { dg-warning "requested alignment .0. is not a positive power of 2" } */ |
| 56 |
A (1, faligned_1, aligned (1)); |
| 57 |
A (0, faligned_1, aligned (2)); |
| 58 |
A (0, faligned_1, aligned (4)); |
| 59 |
|
| 60 |
A (1, faligned_2, aligned); |
| 61 |
A (0, faligned_2, aligned (0)); /* { dg-warning "requested alignment .0. is not a positive power of 2" } */ |
| 62 |
A (0, faligned_2, aligned (1)); |
| 63 |
A (1, faligned_2, aligned (2)); |
| 64 |
A (0, faligned_2, aligned (4)); |
| 65 |
} |
| 66 |
|
| 67 |
|
| 68 |
void test_alloc_align (void) |
| 69 |
{ |
| 70 |
A (0, fnone, alloc_align); |
| 71 |
A (0, falloc_size_1, alloc_align); |
| 72 |
A (1, falloc_align_1, alloc_align); |
| 73 |
A (1, falloc_align_2, alloc_align); |
| 74 |
|
| 75 |
A (0, fnone, alloc_align (1)); /* { dg-warning "\\\[-Wattributes" } */ |
| 76 |
A (0, falloc_size_1, alloc_align (1)); |
| 77 |
A (1, falloc_align_1, alloc_align (1)); |
| 78 |
A (0, falloc_align_2, alloc_align (1)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 79 |
A (1, falloc_align_2, alloc_align (2)); |
| 80 |
} |
| 81 |
|
| 82 |
|
| 83 |
void test_alloc_size_malloc (void) |
| 84 |
{ |
| 85 |
A (0, fnone, alloc_size); |
| 86 |
A (0, fnone, alloc_size (1)); /* { dg-warning "\\\[-Wattributes" } */ |
| 87 |
A (0, fnone, alloc_size (2)); /* { dg-warning "\\\[-Wattributes" } */ |
| 88 |
A (0, falloc_align_1, alloc_size (1)); |
| 89 |
A (0, falloc_align_2, alloc_size (1)); |
| 90 |
A (1, falloc_size_1, alloc_size (1)); |
| 91 |
A (0, falloc_size_1, alloc_size (2)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 92 |
A (0, falloc_size_2, alloc_size (1)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 93 |
A (1, falloc_size_2, alloc_size (2)); |
| 94 |
|
| 95 |
A (1, falloc_size_2_4, alloc_size); |
| 96 |
/* It would probably make more sense to have the built-in return |
| 97 |
true only when both alloc_size arguments match, not just one |
| 98 |
or the other. */ |
| 99 |
A (0, falloc_size_2_4, alloc_size (1)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 100 |
A (1, falloc_size_2_4, alloc_size (2)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 101 |
A (0, falloc_size_2_4, alloc_size (3)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 102 |
A (1, falloc_size_2_4, alloc_size (4)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 103 |
A (1, falloc_size_2_4, alloc_size (2, 4)); |
| 104 |
|
| 105 |
extern ATTR (alloc_size (3)) |
| 106 |
void* fmalloc_size_3 (int, int, int); |
| 107 |
|
| 108 |
A (1, fmalloc_size_3, alloc_size); |
| 109 |
A (0, fmalloc_size_3, alloc_size (1)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 110 |
A (0, fmalloc_size_3, alloc_size (2)); /* { dg-bogus "\\\[-Wattributes" "pr?????" { xfail *-*-* } }" */ |
| 111 |
A (1, fmalloc_size_3, alloc_size (3)); |
| 112 |
A (0, fmalloc_size_3, malloc); |
| 113 |
|
| 114 |
extern ATTR (malloc) |
| 115 |
void* fmalloc_size_3 (int, int, int); |
| 116 |
|
| 117 |
A (1, fmalloc_size_3, alloc_size (3)); |
| 118 |
A (1, fmalloc_size_3, malloc); |
| 119 |
} |
| 120 |
|
| 121 |
#ifndef SKIP_ALIAS |
| 122 |
void test_alias (void) |
| 123 |
{ |
| 124 |
A (0, fnoreturn, alias); |
| 125 |
A (1, falias, alias); |
| 126 |
A (1, falias, alias ("fnoreturn")); |
| 127 |
A (0, falias, alias ("falias")); |
| 128 |
A (0, falias, alias ("fnone")); |
| 129 |
} |
| 130 |
#endif |
| 131 |
|
| 132 |
void test_cold_hot (void) |
| 133 |
{ |
| 134 |
extern ATTR (cold) void fcold (void); |
| 135 |
extern ATTR (hot) void fhot (void); |
| 136 |
|
| 137 |
A (0, fnone, cold); |
| 138 |
A (0, fnone, hot); |
| 139 |
|
| 140 |
A (1, fcold, cold); |
| 141 |
A (0, fcold, hot); |
| 142 |
|
| 143 |
A (0, fhot, cold); |
| 144 |
A (1, fhot, hot); |
| 145 |
} |
| 146 |
|
| 147 |
|
| 148 |
void test_const_leaf_pure (void) |
| 149 |
{ |
| 150 |
extern ATTR (const) int fconst (void); |
| 151 |
extern ATTR (leaf) int fleaf (void); |
| 152 |
extern ATTR (pure) int fpure (void); |
| 153 |
|
| 154 |
A (0, fnone, const); |
| 155 |
A (0, fnone, leaf); |
| 156 |
A (0, fnone, pure); |
| 157 |
|
| 158 |
A (1, fconst, const); |
| 159 |
A (0, fconst, leaf); |
| 160 |
A (0, fconst, pure); |
| 161 |
|
| 162 |
A (0, fleaf, const); |
| 163 |
A (1, fleaf, leaf); |
| 164 |
A (0, fleaf, pure); |
| 165 |
|
| 166 |
A (0, fpure, const); |
| 167 |
A (0, fpure, leaf); |
| 168 |
A (1, fpure, pure); |
| 169 |
|
| 170 |
extern ATTR (const, leaf) int fconst_leaf (void); |
| 171 |
|
| 172 |
A (1, fconst_leaf, const); |
| 173 |
A (1, fconst_leaf, leaf); |
| 174 |
|
| 175 |
extern ATTR (leaf, const) int fleaf_const (void); |
| 176 |
|
| 177 |
A (1, fleaf_const, const); |
| 178 |
A (1, fleaf_const, leaf); |
| 179 |
} |
| 180 |
|
| 181 |
|
| 182 |
void test_ctor_dtor (void) |
| 183 |
{ |
| 184 |
extern ATTR (constructor) void fctor (void); |
| 185 |
extern ATTR (destructor) void fdtor (void); |
| 186 |
extern ATTR (constructor, destructor) void fctor_dtor (void); |
| 187 |
|
| 188 |
A (0, fnone, constructor); |
| 189 |
A (0, fnone, destructor); |
| 190 |
|
| 191 |
A (1, fctor, constructor); |
| 192 |
A (1, fdtor, destructor); |
| 193 |
|
| 194 |
extern ATTR (constructor) void fctor_dtor (void); |
| 195 |
extern ATTR (destructor) void fctor_dtor (void); |
| 196 |
extern ATTR (constructor, destructor) void fctor_dtor (void); |
| 197 |
|
| 198 |
A (1, fctor_dtor, constructor); |
| 199 |
A (1, fctor_dtor, destructor); |
| 200 |
} |
| 201 |
|
| 202 |
|
| 203 |
void test_externally_visible (void) |
| 204 |
{ |
| 205 |
extern void fexternally_visible (void); |
| 206 |
|
| 207 |
A (0, fexternally_visible, externally_visible); |
| 208 |
|
| 209 |
extern ATTR (externally_visible) void fexternally_visible (void); |
| 210 |
|
| 211 |
A (1, fexternally_visible, externally_visible); |
| 212 |
} |
| 213 |
|
| 214 |
|
| 215 |
void test_flatten (void) |
| 216 |
{ |
| 217 |
extern void fflatten (void); |
| 218 |
|
| 219 |
A (0, fflatten, flatten); |
| 220 |
|
| 221 |
extern ATTR (flatten) void fflatten (void); |
| 222 |
|
| 223 |
A (1, fflatten, flatten); |
| 224 |
|
| 225 |
extern void fflatten (void); |
| 226 |
|
| 227 |
A (1, fflatten, flatten); |
| 228 |
} |
| 229 |
|
| 230 |
|
| 231 |
ATTR (format (printf, 2, 4)) void |
| 232 |
fformat_printf_2_3 (int, const char*, int, ...); |
| 233 |
|
| 234 |
void test_format (void) |
| 235 |
{ |
| 236 |
A (0, fnone, format); |
| 237 |
A (0, fnone, format (printf)); |
| 238 |
A (0, fnone, format (printf, 2)); |
| 239 |
} |
| 240 |
|
| 241 |
|
| 242 |
inline void finline (void) { } |
| 243 |
inline ATTR (always_inline) void falways_inline (void) { } |
| 244 |
inline ATTR (always_inline, gnu_inline) void falways_gnu_inline (void) { } |
| 245 |
ATTR (noinline) void fnoinline () { } |
| 246 |
|
| 247 |
void test_inline (void) |
| 248 |
{ |
| 249 |
A (0, fnone, always_inline); |
| 250 |
A (0, fnone, gnu_inline); |
| 251 |
A (0, fnone, noinline); |
| 252 |
|
| 253 |
A (0, finline, always_inline); |
| 254 |
A (0, finline, gnu_inline); |
| 255 |
A (0, finline, noinline); |
| 256 |
|
| 257 |
A (1, falways_inline, always_inline); |
| 258 |
A (0, falways_inline, gnu_inline); |
| 259 |
A (0, falways_inline, noinline); |
| 260 |
|
| 261 |
A (1, falways_gnu_inline, always_inline); |
| 262 |
A (1, falways_gnu_inline, gnu_inline); |
| 263 |
A (0, falways_gnu_inline, noinline); |
| 264 |
|
| 265 |
A (0, fnoinline, always_inline); |
| 266 |
A (0, fnoinline, gnu_inline); |
| 267 |
A (1, fnoinline, noinline); |
| 268 |
} |
| 269 |
|
| 270 |
|
| 271 |
ATTR (no_instrument_function) void fno_instrument (void); |
| 272 |
|
| 273 |
ATTR (visibility ("default")) void fdefault (void); |
| 274 |
ATTR (visibility ("hidden")) void fhidden (void); |
| 275 |
ATTR (visibility ("internal")) void finternal (void); |
| 276 |
ATTR (visibility ("protected")) void fprotected (void); |
| 277 |
|
| 278 |
void test_visibility (void) |
| 279 |
{ |
| 280 |
A (0, fnone, visibility ("default")); |
| 281 |
A (0, fnone, visibility ("hidden")); |
| 282 |
A (0, fnone, visibility ("internal")); |
| 283 |
A (0, fnone, visibility ("protected")); |
| 284 |
|
| 285 |
A (1, fdefault, visibility ("default")); |
| 286 |
A (0, fdefault, visibility ("hidden")); |
| 287 |
A (0, fdefault, visibility ("internal")); |
| 288 |
A (0, fdefault, visibility ("protected")); |
| 289 |
|
| 290 |
A (0, fhidden, visibility ("default")); |
| 291 |
A (1, fhidden, visibility ("hidden")); |
| 292 |
A (0, fhidden, visibility ("internal")); |
| 293 |
A (0, fhidden, visibility ("protected")); |
| 294 |
|
| 295 |
A (0, finternal, visibility ("default")); |
| 296 |
A (0, finternal, visibility ("hidden")); |
| 297 |
A (1, finternal, visibility ("internal")); |
| 298 |
A (0, finternal, visibility ("protected")); |
| 299 |
|
| 300 |
A (0, fprotected, visibility ("default")); |
| 301 |
A (0, fprotected, visibility ("hidden")); |
| 302 |
A (0, fprotected, visibility ("internal")); |
| 303 |
A (1, fprotected, visibility ("protected")); |
| 304 |
} |
| 305 |
|
| 306 |
/* { dg-prune-output "specifies less restrictive attribute" } */ |