gcc/testsuite/c-c++-common/builtin-has-attribute-3.c

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