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