gcc/attribs.c

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