gcc/attribs.c

   1 /* Functions dealing with attribute handling, used by most front ends.
   2    Copyright (C) 1992-2015 Free Software Foundation, Inc.
   3
   4 This file is part of GCC.
   5
   6 GCC is free software; you can redistribute it and/or modify it under
   7 the terms of the GNU General Public License as published by the Free
   8 Software Foundation; either version 3, or (at your option) any later
   9 version.
  10
  11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14 for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GCC; see the file COPYING3.  If not see
  18 <http://www.gnu.org/licenses/>.  */
  19
  20 #include "config.h"
  21 #include "system.h"
  22 #include "coretypes.h"
  23 #include "tm.h"
  24 #include "hash-set.h"
  25 #include "vec.h"
  26 #include "symtab.h"
  27 #include "input.h"
  28 #include "alias.h"
  29 #include "inchash.h"
  30 #include "tree.h"
  31 #include "stringpool.h"
  32 #include "attribs.h"
  33 #include "stor-layout.h"
  34 #include "flags.h"
  35 #include "diagnostic-core.h"
  36 #include "ggc.h"
  37 #include "tm_p.h"
  38 #include "cpplib.h"
  39 #include "target.h"
  40 #include "langhooks.h"
  41 #include "hash-table.h"
  42 #include "plugin.h"
  43
  44 /* Table of the tables of attributes (common, language, format, machine)
  45    searched.  */
  46 static const struct attribute_spec *attribute_tables[4];
  47
  48 /* Substring representation.  */
  49
  50 struct substring
  51 {
  52   const char *str;
  53   int length;
  54 };
  55
  56 /* Simple hash function to avoid need to scan whole string.  */
  57
  58 static inline hashval_t
  59 substring_hash (const char *str, int l)
  60 {
  61   return str[0] + str[l - 1] * 256 + l * 65536;
  62 }
  63
  64 /* Used for attribute_hash.  */
  65
  66 struct attribute_hasher : typed_noop_remove <attribute_spec>
  67 {
  68   typedef attribute_spec *value_type;
  69   typedef substring *compare_type;
  70   static inline hashval_t hash (const attribute_spec *);
  71   static inline bool equal (const attribute_spec *, const substring *);
  72 };
  73
  74 inline hashval_t
  75 attribute_hasher::hash (const attribute_spec *spec)
  76 {
  77   const int l = strlen (spec->name);
  78   return substring_hash (spec->name, l);
  79 }
  80
  81 inline bool
  82 attribute_hasher::equal (const attribute_spec *spec, const substring *str)
  83 {
  84   return (strncmp (spec->name, str->str, str->length) == 0
  85           && !spec->name[str->length]);
  86 }
  87
  88 /* Scoped attribute name representation.  */
  89
  90 struct scoped_attributes
  91 {
  92   const char *ns;
  93   vec<attribute_spec> attributes;
  94   hash_table<attribute_hasher> *attribute_hash;
  95 };
  96
  97 /* The table of scope attributes.  */
  98 static vec<scoped_attributes> attributes_table;
  99
 100 static scoped_attributes* find_attribute_namespace (const char*);
 101 static void register_scoped_attribute (const struct attribute_spec *,
 102                                        scoped_attributes *);
 103
 104 static bool attributes_initialized = false;
 105
 106 /* Default empty table of attributes.  */
 107
 108 static const struct attribute_spec empty_attribute_table[] =
 109 {
 110   { NULL, 0, 0, false, false, false, NULL, false }
 111 };
 112
 113 /* Return base name of the attribute.  Ie '__attr__' is turned into 'attr'.
 114    To avoid need for copying, we simply return length of the string.  */
 115
 116 static void
 117 extract_attribute_substring (struct substring *str)
 118 {
 119   if (str->length > 4 && str->str[0] == '_' && str->str[1] == '_'
 120       && str->str[str->length - 1] == '_' && str->str[str->length - 2] == '_')
 121     {
 122       str->length -= 4;
 123       str->str += 2;
 124     }
 125 }
 126
 127 /* Insert an array of attributes ATTRIBUTES into a namespace.  This
 128    array must be NULL terminated.  NS is the name of attribute
 129    namespace.  The function returns the namespace into which the
 130    attributes have been registered.  */
 131
 132 scoped_attributes*
 133 register_scoped_attributes (const struct attribute_spec * attributes,
 134                             const char* ns)
 135 {
 136   scoped_attributes *result = NULL;
 137
 138   /* See if we already have attributes in the namespace NS.  */
 139   result = find_attribute_namespace (ns);
 140
 141   if (result == NULL)
 142     {
 143       /* We don't have any namespace NS yet.  Create one.  */
 144       scoped_attributes sa;
 145
 146       if (!attributes_table.is_empty ())
 147         attributes_table.create (64);
 148
 149       memset (&sa, 0, sizeof (sa));
 150       sa.ns = ns;
 151       sa.attributes.create (64);
 152       result = attributes_table.safe_push (sa);
 153       result->attribute_hash = new hash_table<attribute_hasher> (200);
 154     }
 155
 156   /* Really add the attributes to their namespace now.  */
 157   for (unsigned i = 0; attributes[i].name != NULL; ++i)
 158     {
 159       result->attributes.safe_push (attributes[i]);
 160       register_scoped_attribute (&attributes[i], result);
 161     }
 162
 163   gcc_assert (result != NULL);
 164
 165   return result;
 166 }
 167
 168 /* Return the namespace which name is NS, NULL if none exist.  */
 169
 170 static scoped_attributes*
 171 find_attribute_namespace (const char* ns)
 172 {
 173   unsigned ix;
 174   scoped_attributes *iter;
 175
 176   FOR_EACH_VEC_ELT (attributes_table, ix, iter)
 177     if (ns == iter->ns
 178         || (iter->ns != NULL
 179             && ns != NULL
 180             && !strcmp (iter->ns, ns)))
 181       return iter;
 182   return NULL;
 183 }
 184
 185 /* Initialize attribute tables, and make some sanity checks
 186    if --enable-checking.  */
 187
 188 void
 189 init_attributes (void)
 190 {
 191   size_t i;
 192
 193   if (attributes_initialized)
 194     return;
 195
 196   attribute_tables[0] = lang_hooks.common_attribute_table;
 197   attribute_tables[1] = lang_hooks.attribute_table;
 198   attribute_tables[2] = lang_hooks.format_attribute_table;
 199   attribute_tables[3] = targetm.attribute_table;
 200
 201   /* Translate NULL pointers to pointers to the empty table.  */
 202   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 203     if (attribute_tables[i] == NULL)
 204       attribute_tables[i] = empty_attribute_table;
 205
 206 #ifdef ENABLE_CHECKING
 207   /* Make some sanity checks on the attribute tables.  */
 208   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 209     {
 210       int j;
 211
 212       for (j = 0; attribute_tables[i][j].name != NULL; j++)
 213         {
 214           /* The name must not begin and end with __.  */
 215           const char *name = attribute_tables[i][j].name;
 216           int len = strlen (name);
 217
 218           gcc_assert (!(name[0] == '_' && name[1] == '_'
 219                         && name[len - 1] == '_' && name[len - 2] == '_'));
 220
 221           /* The minimum and maximum lengths must be consistent.  */
 222           gcc_assert (attribute_tables[i][j].min_length >= 0);
 223
 224           gcc_assert (attribute_tables[i][j].max_length == -1
 225                       || (attribute_tables[i][j].max_length
 226                           >= attribute_tables[i][j].min_length));
 227
 228           /* An attribute cannot require both a DECL and a TYPE.  */
 229           gcc_assert (!attribute_tables[i][j].decl_required
 230                       || !attribute_tables[i][j].type_required);
 231
 232           /* If an attribute requires a function type, in particular
 233              it requires a type.  */
 234           gcc_assert (!attribute_tables[i][j].function_type_required
 235                       || attribute_tables[i][j].type_required);
 236         }
 237     }
 238
 239   /* Check that each name occurs just once in each table.  */
 240   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 241     {
 242       int j, k;
 243       for (j = 0; attribute_tables[i][j].name != NULL; j++)
 244         for (k = j + 1; attribute_tables[i][k].name != NULL; k++)
 245           gcc_assert (strcmp (attribute_tables[i][j].name,
 246                               attribute_tables[i][k].name));
 247     }
 248   /* Check that no name occurs in more than one table.  Names that
 249      begin with '*' are exempt, and may be overridden.  */
 250   for (i = 0; i < ARRAY_SIZE (attribute_tables); i++)
 251     {
 252       size_t j, k, l;
 253
 254       for (j = i + 1; j < ARRAY_SIZE (attribute_tables); j++)
 255         for (k = 0; attribute_tables[i][k].name != NULL; k++)
 256           for (l = 0; attribute_tables[j][l].name != NULL; l++)
 257             gcc_assert (attribute_tables[i][k].name[0] == '*'
 258                         || strcmp (attribute_tables[i][k].name,
 259                                    attribute_tables[j][l].name));
 260     }
 261 #endif
 262
 263   for (i = 0; i < ARRAY_SIZE (attribute_tables); ++i)
 264     /* Put all the GNU attributes into the "gnu" namespace.  */
 265     register_scoped_attributes (attribute_tables[i], "gnu");
 266
 267   invoke_plugin_callbacks (PLUGIN_ATTRIBUTES, NULL);
 268   attributes_initialized = true;
 269 }
 270
 271 /* Insert a single ATTR into the attribute table.  */
 272
 273 void
 274 register_attribute (const struct attribute_spec *attr)
 275 {
 276   register_scoped_attribute (attr, find_attribute_namespace ("gnu"));
 277 }
 278
 279 /* Insert a single attribute ATTR into a namespace of attributes.  */
 280
 281 static void
 282 register_scoped_attribute (const struct attribute_spec *attr,
 283                            scoped_attributes *name_space)
 284 {
 285   struct substring str;
 286   attribute_spec **slot;
 287
 288   gcc_assert (attr != NULL && name_space != NULL);
 289
 290   gcc_assert (name_space->attribute_hash);
 291
 292   str.str = attr->name;
 293   str.length = strlen (str.str);
 294
 295   /* Attribute names in the table must be in the form 'text' and not
 296      in the form '__text__'.  */
 297   gcc_assert (str.length > 0 && str.str[0] != '_');
 298
 299   slot = name_space->attribute_hash
 300          ->find_slot_with_hash (&str, substring_hash (str.str, str.length),
 301                                 INSERT);
 302   gcc_assert (!*slot || attr->name[0] == '*');
 303   *slot = CONST_CAST (struct attribute_spec *, attr);
 304 }
 305
 306 /* Return the spec for the scoped attribute with namespace NS and
 307    name NAME.   */
 308
 309 static const struct attribute_spec *
 310 lookup_scoped_attribute_spec (const_tree ns, const_tree name)
 311 {
 312   struct substring attr;
 313   scoped_attributes *attrs;
 314
 315   const char *ns_str = (ns != NULL_TREE) ? IDENTIFIER_POINTER (ns): NULL;
 316
 317   attrs = find_attribute_namespace (ns_str);
 318
 319   if (attrs == NULL)
 320     return NULL;
 321
 322   attr.str = IDENTIFIER_POINTER (name);
 323   attr.length = IDENTIFIER_LENGTH (name);
 324   extract_attribute_substring (&attr);
 325   return attrs->attribute_hash->find_with_hash (&attr,
 326                                                 substring_hash (attr.str,
 327                                                                 attr.length));
 328 }
 329
 330 /* Return the spec for the attribute named NAME.  If NAME is a TREE_LIST,
 331    it also specifies the attribute namespace.  */
 332
 333 const struct attribute_spec *
 334 lookup_attribute_spec (const_tree name)
 335 {
 336   tree ns;
 337   if (TREE_CODE (name) == TREE_LIST)
 338     {
 339       ns = TREE_PURPOSE (name);
 340       name = TREE_VALUE (name);
 341     }
 342   else
 343     ns = get_identifier ("gnu");
 344   return lookup_scoped_attribute_spec (ns, name);
 345 }
 346
 347
 348 /* Return the namespace of the attribute ATTR.  This accessor works on
 349    GNU and C++11 (scoped) attributes.  On GNU attributes,
 350    it returns an identifier tree for the string "gnu".
 351
 352    Please read the comments of cxx11_attribute_p to understand the
 353    format of attributes.  */
 354
 355 static tree
 356 get_attribute_namespace (const_tree attr)
 357 {
 358   if (cxx11_attribute_p (attr))
 359     return TREE_PURPOSE (TREE_PURPOSE (attr));
 360   return get_identifier ("gnu");
 361 }
 362
 363
 364 /* Process the attributes listed in ATTRIBUTES and install them in *NODE,
 365    which is either a DECL (including a TYPE_DECL) or a TYPE.  If a DECL,
 366    it should be modified in place; if a TYPE, a copy should be created
 367    unless ATTR_FLAG_TYPE_IN_PLACE is set in FLAGS.  FLAGS gives further
 368    information, in the form of a bitwise OR of flags in enum attribute_flags
 369    from tree.h.  Depending on these flags, some attributes may be
 370    returned to be applied at a later stage (for example, to apply
 371    a decl attribute to the declaration rather than to its type).  */
 372
 373 tree
 374 decl_attributes (tree *node, tree attributes, int flags)
 375 {
 376   tree a;
 377   tree returned_attrs = NULL_TREE;
 378
 379   if (TREE_TYPE (*node) == error_mark_node || attributes == error_mark_node)
 380     return NULL_TREE;
 381
 382   if (!attributes_initialized)
 383     init_attributes ();
 384
 385   /* If this is a function and the user used #pragma GCC optimize, add the
 386      options to the attribute((optimize(...))) list.  */
 387   if (TREE_CODE (*node) == FUNCTION_DECL && current_optimize_pragma)
 388     {
 389       tree cur_attr = lookup_attribute ("optimize", attributes);
 390       tree opts = copy_list (current_optimize_pragma);
 391
 392       if (! cur_attr)
 393         attributes
 394           = tree_cons (get_identifier ("optimize"), opts, attributes);
 395       else
 396         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
 397     }
 398
 399   if (TREE_CODE (*node) == FUNCTION_DECL
 400       && optimization_current_node != optimization_default_node
 401       && !DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node))
 402     DECL_FUNCTION_SPECIFIC_OPTIMIZATION (*node) = optimization_current_node;
 403
 404   /* If this is a function and the user used #pragma GCC target, add the
 405      options to the attribute((target(...))) list.  */
 406   if (TREE_CODE (*node) == FUNCTION_DECL
 407       && current_target_pragma
 408       && targetm.target_option.valid_attribute_p (*node, NULL_TREE,
 409                                                   current_target_pragma, 0))
 410     {
 411       tree cur_attr = lookup_attribute ("target", attributes);
 412       tree opts = copy_list (current_target_pragma);
 413
 414       if (! cur_attr)
 415         attributes = tree_cons (get_identifier ("target"), opts, attributes);
 416       else
 417         TREE_VALUE (cur_attr) = chainon (opts, TREE_VALUE (cur_attr));
 418     }
 419
 420   /* A "naked" function attribute implies "noinline" and "noclone" for
 421      those targets that support it.  */
 422   if (TREE_CODE (*node) == FUNCTION_DECL
 423       && attributes
 424       && lookup_attribute_spec (get_identifier ("naked"))
 425       && lookup_attribute ("naked", attributes) != NULL)
 426     {
 427       if (lookup_attribute ("noinline", attributes) == NULL)
 428         attributes = tree_cons (get_identifier ("noinline"), NULL, attributes);
 429
 430       if (lookup_attribute ("noclone", attributes) == NULL)
 431         attributes = tree_cons (get_identifier ("noclone"),  NULL, attributes);
 432     }
 433
 434   targetm.insert_attributes (*node, &attributes);
 435
 436   for (a = attributes; a; a = TREE_CHAIN (a))
 437     {
 438       tree ns = get_attribute_namespace (a);
 439       tree name = get_attribute_name (a);
 440       tree args = TREE_VALUE (a);
 441       tree *anode = node;
 442       const struct attribute_spec *spec =
 443         lookup_scoped_attribute_spec (ns, name);
 444       bool no_add_attrs = 0;
 445       int fn_ptr_quals = 0;
 446       tree fn_ptr_tmp = NULL_TREE;
 447
 448       if (spec == NULL)
 449         {
 450           if (!(flags & (int) ATTR_FLAG_BUILT_IN))
 451             {
 452               if (ns == NULL_TREE || !cxx11_attribute_p (a))
 453                 warning (OPT_Wattributes, "%qE attribute directive ignored",
 454                          name);
 455               else
 456                 warning (OPT_Wattributes,
 457                          "%<%E::%E%> scoped attribute directive ignored",
 458                          ns, name);
 459             }
 460           continue;
 461         }
 462       else if (list_length (args) < spec->min_length
 463                || (spec->max_length >= 0
 464                    && list_length (args) > spec->max_length))
 465         {
 466           error ("wrong number of arguments specified for %qE attribute",
 467                  name);
 468           continue;
 469         }
 470       gcc_assert (is_attribute_p (spec->name, name));
 471
 472       if (TYPE_P (*node)
 473           && cxx11_attribute_p (a)
 474           && !(flags & ATTR_FLAG_TYPE_IN_PLACE))
 475         {
 476           /* This is a c++11 attribute that appertains to a
 477              type-specifier, outside of the definition of, a class
 478              type.  Ignore it.  */
 479           warning (OPT_Wattributes, "attribute ignored");
 480           inform (input_location,
 481                   "an attribute that appertains to a type-specifier "
 482                   "is ignored");
 483           continue;
 484         }
 485
 486       if (spec->decl_required && !DECL_P (*anode))
 487         {
 488           if (flags & ((int) ATTR_FLAG_DECL_NEXT
 489                        | (int) ATTR_FLAG_FUNCTION_NEXT
 490                        | (int) ATTR_FLAG_ARRAY_NEXT))
 491             {
 492               /* Pass on this attribute to be tried again.  */
 493               returned_attrs = tree_cons (name, args, returned_attrs);
 494               continue;
 495             }
 496           else
 497             {
 498               warning (OPT_Wattributes, "%qE attribute does not apply to types",
 499                        name);
 500               continue;
 501             }
 502         }
 503
 504       /* If we require a type, but were passed a decl, set up to make a
 505          new type and update the one in the decl.  ATTR_FLAG_TYPE_IN_PLACE
 506          would have applied if we'd been passed a type, but we cannot modify
 507          the decl's type in place here.  */
 508       if (spec->type_required && DECL_P (*anode))
 509         {
 510           anode = &TREE_TYPE (*anode);
 511           flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 512         }
 513
 514       if (spec->function_type_required && TREE_CODE (*anode) != FUNCTION_TYPE
 515           && TREE_CODE (*anode) != METHOD_TYPE)
 516         {
 517           if (TREE_CODE (*anode) == POINTER_TYPE
 518               && (TREE_CODE (TREE_TYPE (*anode)) == FUNCTION_TYPE
 519                   || TREE_CODE (TREE_TYPE (*anode)) == METHOD_TYPE))
 520             {
 521               /* OK, this is a bit convoluted.  We can't just make a copy
 522                  of the pointer type and modify its TREE_TYPE, because if
 523                  we change the attributes of the target type the pointer
 524                  type needs to have a different TYPE_MAIN_VARIANT.  So we
 525                  pull out the target type now, frob it as appropriate, and
 526                  rebuild the pointer type later.
 527
 528                  This would all be simpler if attributes were part of the
 529                  declarator, grumble grumble.  */
 530               fn_ptr_tmp = TREE_TYPE (*anode);
 531               fn_ptr_quals = TYPE_QUALS (*anode);
 532               anode = &fn_ptr_tmp;
 533               flags &= ~(int) ATTR_FLAG_TYPE_IN_PLACE;
 534             }
 535           else if (flags & (int) ATTR_FLAG_FUNCTION_NEXT)
 536             {
 537               /* Pass on this attribute to be tried again.  */
 538               returned_attrs = tree_cons (name, args, returned_attrs);
 539               continue;
 540             }
 541
 542           if (TREE_CODE (*anode) != FUNCTION_TYPE
 543               && TREE_CODE (*anode) != METHOD_TYPE)
 544             {
 545               warning (OPT_Wattributes,
 546                        "%qE attribute only applies to function types",
 547                        name);
 548               continue;
 549             }
 550         }
 551
 552       if (TYPE_P (*anode)
 553           && (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 554           && TYPE_SIZE (*anode) != NULL_TREE)
 555         {
 556           warning (OPT_Wattributes, "type attributes ignored after type is already defined");
 557           continue;
 558         }
 559
 560       if (spec->handler != NULL)
 561         {
 562           int cxx11_flag =
 563             cxx11_attribute_p (a) ? ATTR_FLAG_CXX11 : 0;
 564
 565           returned_attrs = chainon ((*spec->handler) (anode, name, args,
 566                                                       flags|cxx11_flag,
 567                                                       &no_add_attrs),
 568                                     returned_attrs);
 569         }
 570
 571       /* Layout the decl in case anything changed.  */
 572       if (spec->type_required && DECL_P (*node)
 573           && (TREE_CODE (*node) == VAR_DECL
 574               || TREE_CODE (*node) == PARM_DECL
 575               || TREE_CODE (*node) == RESULT_DECL))
 576         relayout_decl (*node);
 577
 578       if (!no_add_attrs)
 579         {
 580           tree old_attrs;
 581           tree a;
 582
 583           if (DECL_P (*anode))
 584             old_attrs = DECL_ATTRIBUTES (*anode);
 585           else
 586             old_attrs = TYPE_ATTRIBUTES (*anode);
 587
 588           for (a = lookup_attribute (spec->name, old_attrs);
 589                a != NULL_TREE;
 590                a = lookup_attribute (spec->name, TREE_CHAIN (a)))
 591             {
 592               if (simple_cst_equal (TREE_VALUE (a), args) == 1)
 593                 break;
 594             }
 595
 596           if (a == NULL_TREE)
 597             {
 598               /* This attribute isn't already in the list.  */
 599               if (DECL_P (*anode))
 600                 DECL_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 601               else if (flags & (int) ATTR_FLAG_TYPE_IN_PLACE)
 602                 {
 603                   TYPE_ATTRIBUTES (*anode) = tree_cons (name, args, old_attrs);
 604                   /* If this is the main variant, also push the attributes
 605                      out to the other variants.  */
 606                   if (*anode == TYPE_MAIN_VARIANT (*anode))
 607                     {
 608                       tree variant;
 609                       for (variant = *anode; variant;
 610                            variant = TYPE_NEXT_VARIANT (variant))
 611                         {
 612                           if (TYPE_ATTRIBUTES (variant) == old_attrs)
 613                             TYPE_ATTRIBUTES (variant)
 614                               = TYPE_ATTRIBUTES (*anode);
 615                           else if (!lookup_attribute
 616                                    (spec->name, TYPE_ATTRIBUTES (variant)))
 617                             TYPE_ATTRIBUTES (variant) = tree_cons
 618                               (name, args, TYPE_ATTRIBUTES (variant));
 619                         }
 620                     }
 621                 }
 622               else
 623                 *anode = build_type_attribute_variant (*anode,
 624                                                        tree_cons (name, args,
 625                                                                   old_attrs));
 626             }
 627         }
 628
 629       if (fn_ptr_tmp)
 630         {
 631           /* Rebuild the function pointer type and put it in the
 632              appropriate place.  */
 633           fn_ptr_tmp = build_pointer_type (fn_ptr_tmp);
 634           if (fn_ptr_quals)
 635             fn_ptr_tmp = build_qualified_type (fn_ptr_tmp, fn_ptr_quals);
 636           if (DECL_P (*node))
 637             TREE_TYPE (*node) = fn_ptr_tmp;
 638           else
 639             {
 640               gcc_assert (TREE_CODE (*node) == POINTER_TYPE);
 641               *node = fn_ptr_tmp;
 642             }
 643         }
 644     }
 645
 646   return returned_attrs;
 647 }
 648
 649 /* Return TRUE iff ATTR has been parsed by the front-end as a C++-11
 650    attribute.
 651
 652    When G++ parses a C++11 attribute, it is represented as
 653    a TREE_LIST which TREE_PURPOSE is itself a TREE_LIST.  TREE_PURPOSE
 654    (TREE_PURPOSE (ATTR)) is the namespace of the attribute, and the
 655    TREE_VALUE (TREE_PURPOSE (ATTR)) is its non-qualified name.  Please
 656    use get_attribute_namespace and get_attribute_name to retrieve the
 657    namespace and name of the attribute, as these accessors work with
 658    GNU attributes as well.  */
 659
 660 bool
 661 cxx11_attribute_p (const_tree attr)
 662 {
 663   if (attr == NULL_TREE
 664       || TREE_CODE (attr) != TREE_LIST)
 665     return false;
 666
 667   return (TREE_CODE (TREE_PURPOSE (attr)) == TREE_LIST);
 668 }
 669
 670 /* Return the name of the attribute ATTR.  This accessor works on GNU
 671    and C++11 (scoped) attributes.
 672
 673    Please read the comments of cxx11_attribute_p to understand the
 674    format of attributes.  */
 675
 676 tree
 677 get_attribute_name (const_tree attr)
 678 {
 679   if (cxx11_attribute_p (attr))
 680     return TREE_VALUE (TREE_PURPOSE (attr));
 681   return TREE_PURPOSE (attr);
 682 }
 683
 684 /* Subroutine of set_method_tm_attributes.  Apply TM attribute ATTR
 685    to the method FNDECL.  */
 686
 687 void
 688 apply_tm_attr (tree fndecl, tree attr)
 689 {
 690   decl_attributes (&TREE_TYPE (fndecl), tree_cons (attr, NULL, NULL), 0);
 691 }